2. 只有当需要明确指出对当前对象的引用时， 才需要使用this关键字，例如， 当需要返回对当前对象的引用时，就常常在return语句这样写：

[java] view plaincopy

1. public class Leaf {  
2.     private int i = 0;  
3.   
4.     public Leaf increment() {  
5.         i++;  
6.         return this;  
7.     }  
8.   
9.     void print() {  
10.         System.out.println("i = " + i);  
11.     }  
12.   
13.     public static void main(String[] args) {  
14.         Leaf x = new Leaf();  
15.         x.increment().increment().increment().print();  
16.     }  
17. }   

3. 为什么需要finalize()方法？
把一个对象用完后就“弃之不顾”的做法并非总是安全的，当然，java有垃圾回收器负责回收无用对象占据的内存资源，但也有特殊情况：假定你的对象（并非使用new）获得了一块“特殊”的内存区域，由于垃圾回收器只知道释放那些经由new分配的内存，所以它不知道该如何释放该对象的这块“特殊”内存。为了应对这种情况，java允许在类中定义一个名为finalize（）的方法。

不该将finalize（）作为通用的清理方法。

之所以要有finalize（），是由于在分配内存时可能采用了类似C语言中的做法，而非Java中的通常做法，这种噢概念情况主要发生在使用“本地方法”的情况下，本地方法是一种在Java中调用非Java代码的方式。

无论是“垃圾回收”还是“终结方法”都不保证一定会发生，如果Java虚拟机并未面临内存耗尽的情形，它是不会浪费时间
去执行垃圾回收以恢复内存的。

4.初始化顺序：
在类的内部，变量定义的先后顺序决定了初始化的顺序，即使变量定义散布于方法定义之间，他们仍然会在任何方法（包括构造器）被调用之前得到初始化。

[java] view plaincopy

1. class Window {  
2.     Window(int marker) {  
3.         print("Window(" + marker + ")");  
4.     }  
5. }  
6.   
7. class House {  
8.     Window w1 = new Window(1); // Before constructor  
9.   
10.     House() {  
11.         // Show that we‘re in the constructor:  
12.         print("House()");  
13.         w3 = new Window(33); // Reinitialize w3  
14.     }  
15.   
16.     Window w2 = new Window(2); // After constructor  
17.   
18.     void f() {  
19.         print("f()");  
20.     }  
21.   
22.     Window w3 = new Window(3); // At end  
23. }  
24.   
25. public class OrderOfInitialization {  
26.     public static void main(String[] args) {  
27.         House h = new House();  
28.         h.f(); // Shows that construction is done  
29.     }  
30. }   
31. /* Output: 
32. Window(1) 
33. Window(2) 
34. Window(3) 
35. House() 
36. Window(33) 
37. f() 
38. *///:~  

[java] view plaincopy

1. class Bowl {  
2.     Bowl(int marker) {  
3.         print("Bowl(" + marker + ")");  
4.     }  
5.   
6.     void f1(int marker) {  
7.         print("f1(" + marker + ")");  
8.     }  
9. }  
10.   
11. class Table {  
12.     static Bowl bowl1 = new Bowl(1);  
13.   
14.     Table() {  
15.         print("Table()");  
16.         bowl2.f1(1);  
17.     }  
18.   
19.     void f2(int marker) {  
20.         print("f2(" + marker + ")");  
21.     }  
22.   
23.     static Bowl bowl2 = new Bowl(2);  
24. }  
25.   
26. class Cupboard {  
27.     Bowl bowl3 = new Bowl(3);  
28.   
29.     static Bowl bowl4 = new Bowl(4);  
30.   
31.     Cupboard() {  
32.         print("Cupboard()");  
33.         bowl4.f1(2);  
34.     }  
35.   
36.     void f3(int marker) {  
37.         print("f3(" + marker + ")");  
38.     }  
39.   
40.     static Bowl bowl5 = new Bowl(5);  
41. }  
42.   
43. public class StaticInitialization {  
44.     public static void main(String[] args) {  
45.         print("Creating new Cupboard() in main");  
46.         new Cupboard();  
47.         print("Creating new Cupboard() in main");  
48.         new Cupboard();  
49.         table.f2(1);  
50.         cupboard.f3(1);  
51.     }  
52.   
53.     static Table table = new Table();  
54.   
55.     static Cupboard cupboard = new Cupboard();  
56. }   
57. /* Output: 
58. Bowl(1) 
59. Bowl(2) 
60. Table() 
61. f1(1) 
62. Bowl(4) 
63. Bowl(5) 
64. Bowl(3) 
65. Cupboard() 
66. f1(2) 
67. Creating new Cupboard() in main 
68. Bowl(3) 
69. Cupboard() 
70. f1(2) 
71. Creating new Cupboard() in main 
72. Bowl(3) 
73. Cupboard() 
74. f1(2) 
75. f2(1) 
76. f3(1) 
77. *///:~