《Java程序设计教程》第六章习题

请简述异常处理的方法。

（1）捕捉异常方式：通过 try-catch-finally 结构处理异常。

（2）转移异常方式：将可能发生的异常转移到上层调用该成员方法的方法处。

请阐述递归方法的基本要求。

存在一种分解技术，使原问题可以分解为规模较小的同类问题，相同的分解技术又可以进一步作用在由分解所产生的较小规模的同类问题上，产生更小规模的同类问题；最终可以直接求解在分解之后产生的规模最小或接近最小的问题，且前面的分解技术可以使问题全部归结到这些可以直接求解的问题上；即一方面要求问题可以分解，另一方面要求保证问题的分解不会无限制地进行下去，即程序有可能在有限的时间内完成。

请阐述单体程序设计模式的特点。

单体类只有一个实例对象，且至少有一个引用指向这个实例对象；单体类不能派生出子类。

请写出下面程序的输出结果。

// J_Test.java
public class J_Test {
public static void mb_createException() {
throw new ArrayIndexOutOfBoundsException();
}

public static void mb_method() {
try {
mb_createException();
System.out.print("a");
}
catch(ArithmeticException e) {
System.err.print("b");
}
finally {
System.out.print("c");
}
System.out.print("d");
}

public static void main(String[] args) {
try {
mb_method();
}
catch(Exception e) {
System.err.print('m');
}
System.out.print('n');
}
}

cmn

请编写程序。要求该程序含有一个成员方法 mb_calculate，其参数为整数（int）变量 n，其返回值为在利用 6.2 节例程的 J_Fibonacci 类的成员方法 mb_fibonacci(n) 计算 Fibonacci(n) 的值时所需的调用成员方法 mb_fibonacci 的次数。同时要求该程序含有 main 成员方法，并在 main 成员方法中计算并输出 mb_calculate(20) 和 mb_fibonacci(20) 的值。

// J_Calculate.java
public class J_Calculate {
public static int times = 0;

public static int mb_fibonacci(int n) {
times++;
if(n < 1)
return 0;
else if(n == 1 || n == 2)
return 1;
return mb_fibonacci(n-1) + mb_fibonacci(n-2);
}

public static int mb_calculate(int n) {
times = 0;
mb_fibonacci(n);
return times;
}

public static void main(String[] args) {
System.out.println("mb_calculate(20): " + mb_calculate(20));
System.out.println("mb_fibonacci(20): " + mb_fibonacci(20));
}
}

请编写程序。要求该程序含有一个成员方法 mb_calculate，其参数为整数（int）变量 n，其返回值为在利用 6.2 节例程求解 n 个盘的汉诺塔问题时盘的移动次数。同时要求该程序含有 main 成员方法，并在 main 成员方法中计算并输出 mb_calculate(10) 的值。

// J_Calculate.java
public class J_Calculate {
public static int times = 0;

public static void mb_hanoi(int n, char start, char temp, char end) {
times++;
if(n <= 1)
return;
else {
mb_hanoi(n-1, start, end, temp);
mb_hanoi(n-1, temp, start, end);
}
}

public static int mb_calculate(int n) {
times = 0;
mb_hanoi(n, 'S', 'T', 'E');
return times;
}

public static void main(String[] args) {
System.out.println("mb_calculate(10): " + mb_calculate(10));
}
}

请编写程序。要求分别采用递归方法和非递归方法计算 n 的阶乘：n!=n∗(n−1)∗...∗1n!=n*(n-1)*...*1n!=n∗(n−1)∗...∗1，其中，n 为大于 0 的整数。要求在控制台窗口中分别输出采用这两种方法计算从 1 到 10 的阶乘结果。

// J_Factorial.java
public class J_Factorial {
public static int recursive(int n) {
if(n == 1)
return 1;
return recursive(n-1) * n;
}

public static int nonRecursive(int n) {
int res = 1;
for(int i = 1; i <= n; i++)
res *= i;
return res;
}

public static void main(String[] args) {
System.out.println("Computing Factorial(10):");
System.out.println("Recursive: " + recursive(10));
System.out.println("Non-recursive: " + nonRecursive(10));
}
}

请编写程序。设计一个类，要求这个类存在并且只能存在两个实例对象。

// J_TwoObject.java
public class J_TwoObject {
private static J_TwoObject m_o1 = new J_TwoObject();
private static J_TwoObject m_o2 = new J_TwoObject();

private J_TwoObject() {

}
}

请编写程序。给定大于 0 的整数 n，要求输出由 1 元、2 元和 5 元纸币组成 n 元钱的所有方案。

// J_Scheme.java
public class J_Scheme {
private int[] res = new int[100];
private int cnt = 0;

public void mb_solve(int n, int t, int last) {
if(n == 0) {
System.out.println("Scheme " + (++cnt) + ":");
for(int i = 0; i < t; i++)
System.out.print(res[i] + " ");
System.out.println();
System.out.println();
}
else {
if(n >= 5 && last >= 5) {
res[t] = 5;
mb_solve(n-5, t+1, 5);
}
if(n >= 2 && last >= 2) {
res[t] = 2;
mb_solve(n-2, t+1, 2);
}
if(n >= 1 && last >= 1) {
res[t] = 1;
mb_solve(n-1, t+1, 1);
}
}
}

public static void main(String[] args) {
J_Scheme scheme = new J_Scheme();
scheme.mb_solve(10, 0, 5);
}
}

思考题：请分析 6.2 节计算 Fibonacci 数的例程，然后设计算法并编写程序采用非递归的方法计算 Fibonacci 数。

// J_Fibonacci.java
public class J_Fibonacci {
public static int mb_fibonacci(int n) {
if(n < 1)
return 0;
else if(n == 1 || n == 2)
return 1;
int[] fib = new int[n+1];
fib[0] = 0; fib[1] = fib[2] = 1;
for(int i = 3; i <= n; i++)
fib[i] = fib[i-1] + fib[i-2];
return fib[n];
}
}