7.1 汉诺塔

  1. public class MainClass {
  2.     public static void main(String[] args) {
  3.         int nDisks = 3;
  4.         doTowers(nDisks, 'A', 'B', 'C');
  5.     }
  6.     public static void doTowers(int topN, char from, char inter, char to) {
  7.         if (topN == 1){
  8.             System.out.println("Disk 1 from "
  9.             + from + " to " + to);
  10.         }else {
  11.             doTowers(topN - 1, from, to, inter);
  12.             System.out.println("Disk "
  13.             + topN + " from " + from + " to " + to);
  14.             doTowers(topN - 1, inter, from, to);
  15.         }
  16.     }
  17. }

7.2 斐波那契数列

  1. public class MainClass {
  2.     public static void main(String[] args) {
  3.         for (int counter = 0; counter <= 10; counter++){
  4.             System.out.printf("Fibonacci of %d is: %d\n", counter, fibonacci(counter));
  5.         }
  6.     }
  7.     public static long fibonacci(long number) {
  8.         if ((number == 0) || (number == 1))
  9.             return number;
  10.         else
  11.             return fibonacci(number - 1) + fibonacci(number - 2);
  12.     }
  13. }

7.3 阶乘

  1. public class MainClass {
  2.     public static void main(String args[]) {
  3.         for (int counter = 0; counter <= 10; counter++){
  4.             System.out.printf("%d! = %d\n", counter,
  5.             factorial(counter));
  6.         }
  7.     }
  8.     public static long factorial(long number) {
  9.         if (number <= 1)
  10.             return 1;
  11.         else
  12.             return number * factorial(number - 1);
  13.     }
  14. }

7.4 标签

Java 中的标签是为循环设计的，是为了在多重循环中方便的使用 break 和coutinue 。

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         String strSearch = "This is the string in which you have to search for a substring.";
  4.         String substring = "substring";
  5.         boolean found = false;
  6.         int max = strSearch.length() - substring.length();
  7.         testlbl:
  8.         for (int i = 0; i <= max; i++) {
  9.             int length = substring.length();
  10.             int j = i;
  11.             int k = 0;
  12.             while (length-- != 0) {
  13.                 if(strSearch.charAt(j++) != substring.charAt(k++)){
  14.                     continue testlbl;
  15.                 }
  16.             }
  17.             found = true;
  18.             break testlbl;
  19.         }
  20.         if (found) {
  21.             System.out.println("发现子字符串。");
  22.         }
  23.         else {
  24.             System.out.println("字符串中没有发现子字符串。");
  25.         }
  26.     }
  27. }

7.5 finalize

Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。
例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。

  1. protected void finalize(){
  2.    // 在这里终结代码
  3. }
  4. /* 关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。
  5. 当然，Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用上面的方法
  6. */