java编程思想阅读笔记（二）

static 的含义 
理解了this关键字后，我们可更完整地理解static（静态）方法的含义。它意味着一个特定的方法没有 this。我们不可从一个 static 方法内部发出对非 static方法的调用（注释②），尽管反过来说是可以的。而且在没有任何对象的前提下，我们可针对类本身发出对一个 static 方法的调用。事实上，那正是 static 方法最基本的意义。它就好象我们创建一个全局函数的等价物（在 C语言中）。除了全局函数不允许在Java中使用以外，若将一个static方法置入一个类的内部，它就可以访问其他static方法以及static 字段。 

②：有可能发出这类调用的一种情况是我们将一个对象句柄传到 static 方法内部。随后，通过句柄（此时实际是this），我们可调用非static方法，并访问非static 字段。但一般地，如果真的想要这样做，只要制作一个普通的、非 static方法即可。 

垃圾回收之finalize

垃圾回收器要回收对象的时候，首先要调用这个类的finalize方法(你可以 写程序验证这个结论)，一般的纯Java编写的Class不需要重新覆盖这个方法，因为Object已经实现了一个默认的，除非我们要实现特殊的功能(这 里面涉及到很多东西，比如对象空间树等内容)。 
不过用Java以外的代码编写的Class(比如JNI，C++的new方法分配的内存)，垃圾回收器并不能对这些部分进行正确的回收，这时就需要我们覆盖默认的方法来实现对这部分内存的正确释放和回收(比如C++需要delete)。 
总之，finalize相当于析构函数，他是垃圾回收器回收一个对象的时候第一个要调用的方法。不过由于Java的垃圾回收机制能自动为我们做这些事情，所以我们在一般情况下是不需要自己来手工释放的。

初始化顺序 
在一个类里，初始化的顺序是由变量在类内的定义顺序决定的。即使变量定义大量遍布于方法定义的中间，那些变量仍会在调用任何方法之前得到初始化——甚至在构建器调用之前。例如： 

class Tag {  Tag(int marker) {  System.out.println("Tag(" + marker + ")");  } }  class Card {  Tag t1 = new Tag(1); // Before constructor  Card() {  // Indicate we're in the constructor:  System.out.println("Card()");  t3 = new Tag(33); // Reinitialize t3  }  Tag t2 = new Tag(2); // After constructor  void f() {  System.out.println("f()");  }  Tag t3 = new Tag(3); // At end }  public class OrderOfInitialization {  public static void main(String[] args) {  Card t = new Card();  t.f(); // Shows that construction is done  } } ///:~ 

在Card中，Tag对象的定义故意到处散布，以证明它们全都会在构建器进入或者发生其他任何事情之前得到初始化。除此之外，t3在构建器内部得到了重新初始化。它的输入结果如下： 
Tag(1) 
Tag(2) 
Tag(3) 
Card() 
Tag(33) 
f() 

如果想在定义的同时进行初始化，采取的方法与非静态值表面看起来是相同的。但由于 static值只有一个存储区域，所以无论创建多少个对象，都必然会遇到何时对那个存储区域进行初始化的问题。下面这个例子可将这个问题说更清楚一些： 

class Bowl {  Bowl(int marker) {  System.out.println("Bowl(" + marker + ")");  }  void f(int marker) {  System.out.println("f(" + marker + ")");  } }  class Table {  static Bowl b1 = new Bowl(1);  Table() {  System.out.println("Table()");  b2.f(1);  }  void f2(int marker) {  System.out.println("f2(" + marker + ")");  }  static Bowl b2 = new Bowl(2); }  class Cupboard {  Bowl b3 = new Bowl(3);  static Bowl b4 = new Bowl(4);  Cupboard() {  System.out.println("Cupboard()");  b4.f(2);  }  void f3(int marker) {  System.out.println("f3(" + marker + ")");  }  static Bowl b5 = new Bowl(5); }  public class StaticInitialization {  public static void main(String[] args) {  System.out.println(  "Creating new Cupboard() in main");  new Cupboard();  System.out.println(  "Creating new Cupboard() in main");  new Cupboard();  t2.f2(1);  t3.f3(1);  }  static Table t2 = new Table();  static Cupboard t3 = new Cupboard(); }

Bowl 允许我们检查一个类的创建过程，而 Table 和 Cupboard 能创建散布于类定义中的Bowl 的 static成员。注意在static定义之前，Cupboard先创建了一个非 static的Bowl b3。它的输出结果如下： 

 Bowl(1) 
Bowl(2) 
Table() 
f(1) 
Bowl(4) 
Bowl(5) 
Bowl(3) 
Cupboard() 
f(2) 
Creating new Cupboard() in main 
Bowl(3) 
Cupboard() 
f(2) 
Creating new Cupboard() in main 
Bowl(3) 
Cupboard() 
f(2) 
f2(1) 
f3(1) 

static初始化只有在必要的时候才会进行。如果不创建一个Table 对象，而且永远都不引用 Table.b1或 Table.b2，那么static Bowl b1和 b2 永远都不会创建。然而，只有在创建了第一个Table对象之后（或者发生了第一次 static 访问），它们才会创建。在那以后，static对象不会重新初始化。 初始化的顺序是首先static（如果它们尚未由前一次对象创建过程初始化），接着是非static对象。大家可从输出结果中找到相应的证据。 

在创建对象时，若类存在静态块，无论创建多少个该类的对象，静态块只会执行一次。

隐藏实施过程 

这一点对于库来说是特别重要的。那个库的用户（客户程序员）必须能依赖自己使用的那一部分，并知道一旦新版本的库出台，自己不需要改写代码。而与此相反，库的创建者必须能自由地进行修改与改进，同时保证客户程序员代码不会受到那些变动的影响。