thinking in java 笔记之初始化和清除

背景：“不安全”是程序设计最严重问题之一。“初始化”和“清除”是安全问题中的两个。Java沿用C++“构建器”的概念，在一个对象创建之后自动调用。Java也增加了“垃圾收集器”，在资源不再需要的时候自动释放。
1.1 用构建器自动初始化
Java使用构建器的名字和类名相同，在创建对象时，自动调用构建器。

class Rock {
  Rock() { // This is the constructor
    System.out.println("Creating Rock");
  }
}
public class SimpleConstructor {
  public static void main(String[] args) {
    for(int i = 0; i < 10; i++)
      new Rock();
  }
}

new Rock();执行时，会分配相应的存储空间，并调用构建器。
1.2 方法重载
Java中要求每个函数都是独一无二的。如果我们想用多种方式创建对象，那就需要多个构造器。但是构造器名字必须同类名一样，我们可以给构造器带不同的参数来区分，实现构造器的重载。

class Tree {
  int height;
  Tree() {
    prt("Planting a seedling");
    height = 0;
  }
  Tree(int i) {
    prt("Creating new Tree that is "
        + i + " feet tall");
    height = i;
  }
  void info() {
    prt("Tree is " + height
        + " feet tall");
  }
  void info(String s) {
    prt(s + ": Tree is "
        + height + " feet tall");
  }
  static void prt(String s) {
    System.out.println(s);
  }
}

每个重载的方法都必须采取独一无二的自变量类型列表，包括自变量的类型和顺序。但是不建议以顺序区分，因为这样不易维护代码。还有一点，方法的重载不能根据返回值类型来区分。比如void f(){} 和 int f(){}，如果我们在调用的时候忽略了返回值，则编译器不能识别去调用哪一个方法。
1.3 默认构造器
如果创建一个没有构造器的类，则编译程序会帮我们自动创建一个没有任何变量、空方法体的默认构造器。如果我们自己定义了一个构造器，则程序不会帮我们创建默认构造器。例如：

class Bird {
  int i;
}
public class DefaultConstructor {
  public static void main(String[] args) {
    Bird nc = new Bird(); // 调用默认构造器
  }
}

class Bird {
  Bird(int i ){}
  Bird(float f){}
}
public class DefaultConstructor {
  public static void main(String[] args) {
    Bird nc = new Bird(); // 编译器报错，找不到相符的构造器
  }
}

1.4 this关键字
如果有两个同类型的对象，分别叫作a和b，那么您也许不知道如何为这两个对象同时调用一个f()方法：
class Banana { void f(int i) { /* … */ } }
Banana a = new Banana(), b = new Banana();
a.f(1);
b.f(2);
若只有一个名叫f()的方法，它怎样才能知道自己是为a还是为b调用的呢？
为了能用简便的、面向对象的语法来书写代码——亦即“将消息发给对象”，编译器为我们完成了一些幕后工作。其中的秘密就是第一个自变量传递给方法f()，而且那个自变量是准备操作的那个对象的句柄。所以前述的两个方法调用就变成了下面这样的形式：
Banana.f(a,1);
Banana.f(b,2);
这是内部的表达形式，我们并不能这样书写表达式，并试图让编译器接受它。但是，通过它可理解幕后到底发生了什么情。假定我们在一个方法的内部，并希望获得当前对象的句柄。由于那个句柄是由编译器“秘密”传递的，所以没有标识符用。然而，针对这一目的有个专用的关键字：this。this关键字（注意只能在方法内部使用）可为已调用了其方法的那个对象生成相应的句柄。可象对待其他任何对象句柄一样对待这个句柄。但要注意，假若准备从自己某个类的另一个方法内部调用一个类方法，就不必使用this。只需简单地调用那个方法即可。当前的this句柄会自动应用于其他方法。所以我们能使用下面这样的代码：
class Apricot {
void pick() { /* … */ }
void pit() { pick(); /* … */ }
}
在pit()内部，我们可以说this.pick()，但事实上无此必要。编译器能帮我们自动完成。this关键字只能用于那些特殊的类——需明确使用当前对象的句柄。例如，假若您希望将句柄返回给当前对象，那么它经常在return语句中使用。

public class Leaf {
  private int i = 0;
  Leaf increment() {
    i++;
    return this;
  }
  void print() {
    System.out.println("i = " + i);
  }
  public static void main(String[] args) {
    Leaf x = new Leaf();
    x.increment().increment().increment().print();
  }
}

由于increment()通过this关键字返回当前对象的句柄，所以可以方便地对同一个对象执行多项操作。
① 使用this在构造器里调用构造器，可以避免写重复的代码。通常，当我们说this的时候，都是指“当前对象”，而且它本身会产生当前对象的一个句柄。例如

public class Flower {
  private int petalCount = 0;
  private String s = new String("null");
  Flower(int petals) {
    petalCount = petals;
    System.out.println("Constructor w/ int arg only, petalCount= " + petalCount);
  }
  Flower(String ss) {
    System.out.println("Constructor w/ String arg only, s=" + ss);
    s = ss;
  }
  Flower(String s, int petals) {
    this(petals);
//!    this(s); // Can't call two!
    this.s = s; // Another use of "this"
    System.out.println("String & int args");
  }
  Flower() {
    this("hi", 47);
    System.out.println("default constructor (no args)");
  }
  void print() {
  //!    this(11); // Not inside non-constructor!
    System.out.println( "petalCount = " + petalCount + " s = "+ s);
  }
  public static void main(String[] args) {
    Flower x = new Flower();
    x.print();
  }
}

其中，构建器Flower(String s,int petals)向我们揭示出这样一个问题：尽管可用this调用一个构建器，但不可调用两个。这个例子也向大家展示了this的另一项用途。由于自变量s的名字以及成员数据s的名字是相同的，所以会出现混淆。为解决这个问题，可用this.s来引用成员数据。在print()中，我们发现编译器不让我们从除了一个构建器之外的其他任何方法内部调用一个构建器。
②理解了this关键字后，我们可更完整地理解static（静态）方法的含义。它意味着一个特定的方法没有this。我们不可从一个static方法内部发出对非static方法的调用（注释②），尽管反过来说是可以的。而且在没有任何对象的前提下，我们可针对类本身发出对一个static方法的调用。事实上，那正是static方法最基本的意义。它就好象我们创建一个全局函数的等价物（在C语言中）。除了全局函数不允许在Java中使用以外，若将一个static方法置入一个类的内部，它就可以访问其他static方法以及static字段。

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

有些人抱怨static方法并不是“面向对象”的，因为它们具有全局函数的某些特点；利用static方法，我们不必向对象发送一条消息，因为不存在this。

2. 清除
Java的GC只知道释放那些有new分配的内存，对于一些“特殊”的不由new分配的内存区域，GC不知道如何释放。为了解决这个问题，Java提供了finalize()，工作原理是：一旦GC准备释放对象占用的存储空间，它首先调用finalize()，在下一次垃圾收集过程中，回收对象的内存。所以调用finalize()，对象也不能被立即释放掉。