Think in Java(二)：初始化与清理

1. 区分重载方法：

参数顺序的不同可以区分两个方法，不过，一般情况下千万别这么做，因为这会使代码难以维护不能通过返回值类型来区分重载方法：因为如果我直接调用f(), 此时java不知道应该调用那一个

public void f(){ 
}
public int f(){
return 1;
}

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

public class Leaf {
	private int i = 0;

	public 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关键字返回了对当前对象的引用，所以很容易在一条语句对同一个对象执行多次操作

3. 为什么需要finalize()方法？

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

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

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

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

去执行垃圾回收以恢复内存的。

4.初始化顺序：

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

class Window {
	Window(int marker) {
		print("Window(" + marker + ")");
	}
}

class House {
	Window w1 = new Window(1); // Before constructor

	House() {
		// Show that we're in the constructor:
		print("House()");
		w3 = new Window(33); // Reinitialize w3
	}

	Window w2 = new Window(2); // After constructor

	void f() {
		print("f()");
	}

	Window w3 = new Window(3); // At end
}

public class OrderOfInitialization {
	public static void main(String[] args) {
		House h = new House();
		h.f(); // Shows that construction is done
	}
} 
/* Output:
Window(1)
Window(2)
Window(3)
House()
Window(33)
f()
*///:~

5. 静态数据初始化：

class Bowl {
	Bowl(int marker) {
		print("Bowl(" + marker + ")");
	}

	void f1(int marker) {
		print("f1(" + marker + ")");
	}
}

class Table {
	static Bowl bowl1 = new Bowl(1);

	Table() {
		print("Table()");
		bowl2.f1(1);
	}

	void f2(int marker) {
		print("f2(" + marker + ")");
	}

	static Bowl bowl2 = new Bowl(2);
}

class Cupboard {
	Bowl bowl3 = new Bowl(3);

	static Bowl bowl4 = new Bowl(4);

	Cupboard() {
		print("Cupboard()");
		bowl4.f1(2);
	}

	void f3(int marker) {
		print("f3(" + marker + ")");
	}

	static Bowl bowl5 = new Bowl(5);
}

public class StaticInitialization {
	public static void main(String[] args) {
		print("Creating new Cupboard() in main");
		new Cupboard();
		print("Creating new Cupboard() in main");
		new Cupboard();
		table.f2(1);
		cupboard.f3(1);
	}

	static Table table = new Table();

	static Cupboard cupboard = new Cupboard();
} 
/* Output:
Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)
*///:~

初始化的顺序是先静态对象， 而后是非静态对象，上面的类中要执行main（）（静态方法）必须加载StaticInitialization，然后其静态域table和cupboard被初始化，这将导致它们对应的类也被加载，并且由于它们也都包含静态的Bowl对象，因此Bowl随后也被加载。