初始化与清理

随着计算机革命的发展，“不安全”的编程方式已逐步成为编程代价高昂主要原因之一。
初始化和清理(cleanup)正是涉及安全的两个问题。

用构造器确保初始化

可以假想为编写的每个类都添加initialize方法。
该方法的名称提醒你在使用其对象之前，应该先调用initialize()。
然而，这同事意味着用户必须记得自己去调用此方法。
在Java中，通过提供构造器，类的设计者可确保每个对象都可以得到初始化。
创建对象时，如果其具有构造器，Java就会在用户有能力操作对象之前自动调用相应的构造器，从而保证初始化的进行。


构造器采用了与类相同的名字。


不接收任何参数的构造器叫做无参构造器或者默认构造器。


在Java中，“初始化”和“创建”捆绑在一起，两者不能分离。

方法重载

1、区分重载方法
每个重载方法都必须有一个独一无二的参数类型列表。甚至参数顺序不同都可以（不过一般，不要这么做，这样会使代码难以维护）。




2、涉及基本类型的重载
基类类型能从一个“较小”的类型自动提升至一个“较大”的类型，此过程一但涉及到重载，可能会照成一些混淆。


如果传入的数据类型（实际参数类型）小于方法中声明的形式参数类型，实际数据类型就会被提升。
char略有不同，如果无法找到恰好 接收char参数的方法，就会吧char直接提升至int。
如果实际传入的参数较大，就必须通过类型转换来执行窄化转换，否则，编译器会报错。




3、以返回值区分重载方法。
有时，你并不关心方法的返回值，所以行不通。

默认构造器

如果你写的类中没有构造器，则编译器就会帮你创建一个默认构造器。
但是，如果已经定义了一个构造器，编译器就不会帮你创建一个默认构造器。

this关键字

"所操作对象的引用"作为第一参数。


假设你希望在方法的内部得到当前对象的 引用。
由于这个引用由编译器“偷偷”的传入的，所以没用标示符可用。
但是，为此有个专门的关键字“this”。


this只能在方法内部引用，表示对“调用方法的那个对象”的引用。
如果在方法的内部调用同一个类的另外一个方法，就不必使用this，直接调用就可以(当然，也可以加)。


一般用法就是存在同名传入参数和域变量同名，通过使用this来指明是我自己的，不是传入的那个。




1、在构造器中调用构造器

package cn.partner4java.constructor.demo1;

/**
 * 1、在构造器中调用构造器可以使用this(...)
 * 2、被调用的构造器方法必须放在调用构造器的第一行
 * 3、由于2，在一个构造器中只能调用本类的一个构造器
 * @author partner4java
 *
 */
public class Flower {
	int petalCount = 0;
	String s = "initial value";
	public Flower(int petalCount) {
		this.petalCount = petalCount;
		System.out.println("Constructor int arg only,petalCount=" + petalCount);
	}
	
	public Flower(String s) {
		System.out.println("Constructor String arg only,s=" + s);
		this.s = s;
	}
	
	public Flower(int petalCount,String s) {
		this(petalCount);
//		this(s); //Can't call two;(Constructor call must be the first statement in a constructor)
		this.s = s;
		System.out.println("String & int s");
	}
}

2、static的含义
static方法就是没有this的方法。
在static方法内部不能调用非静态方法，反过来可以。
在没有创建对象的前提下，仅仅通过类本身调用static方法。这实际上这是static方法的主要用途。
很像全局方法，Java中禁止使用全局方法。

清理：终结处理和垃圾回收

JVM：
http://blog.csdn.net/partner4java/article/details/7206650
http://blog.csdn.net/partner4java/article/details/7207741
终结方法：
http://blog.csdn.net/partner4java/article/details/7061188

成员初始化

局部变量不能不初始化。

package cn.partner4java.init.demo2;

public class Init {
	private void f() {
		int i;
		i++;//Error,The local variable i may not have bean initialized
	}
}

全局变量基本类型会默认初始化。


1、指定初始化
需要注意的是指定初始化和初始化顺序。

构造器初始化

无法阻止自动初始化的进行，他将在构造器被调用之前发生。




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




2、静态数据的初始化
无论创建多少个对象，静态数据都只占一份存储区域。
static关键字不能应用于局部变量，因为他只能作用于域。
如果一个域是静态基本类型域，且也没有对他进行初始化，那么他就会获得基本类型的标准初值；如果他是对象引用，那么他的默认初始化值就是null。


静态存储区域是何时初始化的？

package cn.partner4java.init.demo3;

public class Bowl {
	public Bowl(int marker) {
		System.out.println("Bowl(" + marker + ")");
	}
	void f1(int marker){
		System.out.println("f1("+ marker +")");
	}
}


package cn.partner4java.init.demo3;

public class Table {
	static Bowl bowl1 = new Bowl(1);
	public Table() {
		System.out.println("Table()");
		bowl2.f1(1);
	}
	void f2(int marker){
		System.out.println("f2("+ marker +")");
	}
	static Bowl bowl2 = new Bowl(2);
}


package cn.partner4java.init.demo3;

public class Cupboard {
	Bowl bowl3 = new Bowl(3);
	static Bowl bowl4 = new Bowl(4);
	public Cupboard() {
		System.out.println("Cupboard()");
		bowl4.f1(2);
	}
	void f3(int marker){
		System.out.println("f3("+ marker +")");
	}
	static Bowl bowl5 = new Bowl(5);
}


package cn.partner4java.init.demo3;

/**
 * 总结一下创建过程，假设有个名为Dog的类：
 * 1、即使没有显式的使用static关键字，构造器实际上也是静态方法。
 * 因此，当收次创建类为Dog的对象时（构造器可以看做静态方法），
 * 或者Dog的静态方法/静态域首次被访问时，Java解释器必须查找类路径，以定位Dog.class文件。<br/>
 * 2、然后载入Dog.class，有关静态初始化的所有动作都会执行。
 * 因此，静态初始化只在Class对象首次加载的时候进行一次。<b/>
 * 3、当用new Dog()创建对象的时候，首先将在堆上为Dog分配足够的存储空间。<br/>
 * 4、这块存储空间会被清零，这就自动的将Dog的所有基本数据类型设置从了默认值，而引用设置成了null。<br/>
 * 5、执行所有出现于字段定义出的初始化动作。<br/>
 * 6、执行构造器。
 * @author partner4java
 *
 */
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();
		table.f2(1);
		cupboard.f3(1);
	}
	
	static Table table = new Table();
	static Cupboard cupboard = new Cupboard();
}
//后台打印：
//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)

3、显式的静态初始化

Class Cups {
	static Cup cup1;
	static Cup cup2;
	static{
		cup1 = new Cup(1);
		cup2 = new Cup(2);
	}
}

4、非静态实例初始化

package cn.partner4java.init.demo4;

public class Mug {
	public Mug(int marker) {
		System.out.println("Mug("+ marker +")");
	}
	void f(int marker){
		System.out.println("f("+ marker +")");
	}
}


package cn.partner4java.init.demo4;

/**
 * 实例初始化子句在构造器之前执行
 * @author partner4java
 *
 */
public class Mugs {
	Mug mug1;
	Mug mug2;
	{
		mug1 = new Mug(1);
		mug2 = new Mug(2);
		System.out.println("mug1&mug2 initialized");
	}
	public Mugs() {
		System.out.println("Mugs()");
	}
	public Mugs(int i){
		System.out.println("Mugs(int)");
	}
	public static void main(String[] args) {
		System.out.println("Inside main()");
		new Mugs();
		System.out.println("new Mugs() completed");
		new Mugs(1);
		System.out.println("new Mugs(1) completed");
	}
}
//后台打印：
//Inside main()
//Mug(1)
//Mug(2)
//mug1&mug2 initialized
//Mugs()
//new Mugs() completed
//Mug(1)
//Mug(2)
//mug1&mug2 initialized
//Mugs(int)
//new Mugs(1) completed