Java初始化与清理

写在前面：此博客是本人在学习《Thinking in Java》的过程中做的学习笔记，主要参考的内容是《Thinking in Java》这本书，在学识过程中难免有理解错误或者遗漏之处，希望各位大神们批评指正，也欢迎初学者一起探讨~

1. Java初始化

Java初始化与C++类似，均使用构造器完成对象的初始化。构造器的语法与C++相同，均使用与类名相同的、无返回值的函数作为构造器。

1.1 默认构造器

默认构造器是没有形参的一种构造器。如果你编写的类中不包含构造器，则编译器会自动帮你创建一个构造器。若你已经定义了一个构造器，则编译器不会创建默认构造器。

1.2 this关键字

1. this关键字在没有参数列表的下，在构造器中表示方法调用对象的一个引用。编译器默认将this作为第一个参数将对象的引用传递给方法。
   通常在需要返回对象的引用，或者将当前对象传递给其他方法时使用。

public class This{
    int i = 0;
    This increment(){
        i += 2;
        return this;
    }
    void print(){
        System.out.println("i = " + i);
    }
    public static void main(String args[]){
        This x = new This();
        x.increment().increment().print();
    }
} //结果为：4

class Person{
    public void eat(Apple apple){
        Apple peeled = apple.getPeeled();
        System.out.println("Yummy");
    }
}
class Peeler{
    static Apple peel(Apple apple){
        //....remove peel
        return apple;
    }
}
class Apple{
    Apple getPeeled(){
        return Peeler.peel(this);
    }
}
public class This{
    public static void main(String args[]){
        new Person().eat(new Apple());
    }
}

2. 若想在一个构造器中调用另一个构造器，可使用this加参数列表的形式，表示对符合此参数列表的某个构造器的明确调用。

contrast: static关键字
static方法就是没有this的方法，在static方法中不能调用非静态方法和非static变量。
Java中禁止使用全局方法，在类中置入static方法就可以访问其他static方法和static域。

1.3 成员初始化

1. Java要求所有变量在使用之前必须进行初始化，否则产生编译时错误。

void f(){	
	int i;
	i++;    //i未初始化，会在编译时产生错误
}

2. 若变量是定义在类内部的基本类型的变量，会保证数据成员会有初始值。

class InitialValues{
	int i;
	void printInitialValues(){
		System.out.println(i);
	}
	public static void main(String[] args){
		InitialValues iv = new InitialValues();
		iv.printInitialValues();         //输出0
	}
}

3. 指定初始化若想为某个变量赋值，可在定义变量是直接为其赋值。此条不仅适用于基本类型的变量，自定义类也可使用此方法。

class InitialValues{
   int i = 1;
   //...
}

class Depth{}

public class Measurement{
	Depth d = new Depth();    //自定义类型使用指定初始化
	//如果未初始化d就使用它，会产生运行时错误，抛出一个异常
	//...
}

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

public class Counter{
	int i;
	Counter() {i = 7;}
	//...
}//i首先被置为0，然后调用构造器初始化为7

初始化顺序

同C++，按照变量定义顺序进行初始化。
本人注：指定初始化发生在构造器的调用之前，这一点也很重要。

静态数据的初始化

无论创建多少个对象，静态数据只占用一份存储区域。static不能应用于局部变量，因此只能作用于域。如果一个域是静态基本类型域，也没有进行初始化，就会获得基本类型的标准初值；若是一个对象的引用，则初始化为null。
静态初始化只有在必要的时候才会进行。初始化的顺序是先静态对象，后“非静态”对象。

对象创建过程
以创建一个Dog类对象为例：

1. 即使未加static关键字，构造器实际上也是静态方法。首次创建Dog类对象时，解释器查找类的路径，定位Dog.class文件。
2. 加载Dog.class，执行静态初始化动作。静态初始化只在Class对象首次加载时进行一次。
3. 使用new Dog()创建对象时，在堆上为Dog对象分配足够的存储空间。
4. 这块存储空间会被置为默认初始值。
5. 执行所有定义在字段定义处的初始化动作。
6. 执行构造器。

显式的静态初始化

Java中允许将多个静态初始化动作组织成一个特殊的“静态子句”(静态块)

public class Spoon{
	static i;
	static {
		i = 7;
	}
}

静态块中的语句只执行一次，发生在首次生成一个类的对象，或者首次访问属于这个类的静态成员时。

非静态实例初始化

非静态实例初始化有与静态块类似的语法，例：

class Mug {
	Mug(int marker){
		System.out.println("Mug("+marker+")");
	}
	void f(int marker){
		System.out.println("f("+marker+")");
	}
}
class Mugs {
	Mug mug1;
	Mug mug2;
	{
		mug1 = new Mug(1);
		mug2 = new Mug(2);
		System.out.println("mug1 & mug2 are initialized!");
	}
	Mugs(){
		System.out.println("Mugs()");
	}
	Mugs(int marker){
		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!");
	}
}/*Output:
Inside main()
Mug(1)
Mug(2)
mug1 & mug2 are initialized!
Mugs()
new Mugs() completed!
Mug(1)
Mug(2)
mug1 & mug2 are initialized!
Mugs(int)
new Mugs(1) completed!
*/

1.4 数组初始化

Java定义数组方式：

int[] a1;

或者

int a1[];

※注意C++与java区别：Java中不允许指定数组的大小
原因：Java中定义的是数组的引用，未给对象分配任何空间

1. 数组初始化动作可以在代码的任何地方出现，也可使用特殊的初始化表达式，它必须在创建数组的地方出现。这种特殊的初始化方式使用花括号括起来的数值组成的。

int[] a1 = {1,2,3,4,5};

在java中可将一个数组赋值给另一个数组：

int[] a2;
a2 = a1;    //将一个数组赋值给另一个数组

通过此种赋值，a2成为a1的别名，修改a2在a1中可见。

数组长度 length
与C++相同，Java数组下标从0开始，最大下标为length-1。Java在数组越界时，产生运行时错误。（检查越界会产生开销，无法禁用此功能）

2. 若实现不确定数组的大小，可使用new()

import java.util.*
import static net.mindview.util.Print.*

public class ArrayNew{
	public static void main(String[] args){
		int[] a;
		Random rand = new Random(47);
		a = new int[rand.nextInt(20)];
		print("length of a:"+a.length);
		print(a.toString(a));
	}
}

Random,nextInt()会产生0至输入参数之间的一个值。
Array.toString方法属于java.util标准类库，产生一维数组的可打印版本。

引用数组：创建一个非基本类型的数组称为引用数组

如果忘记创建对象，并试图使用数组中的空引用，会在运行时产生异常。

3. 可用花括号括起的列表初始化对象数组

import java.util.*

public class ArrayInit{
	public static void main(String[] args){
		Integer[] a = {
			new Integer(1),
			new Integer(2),
			3
		};
		Integer[] b = new Integer[] {
			new Integer(1),
			new Integer(2),
			3
		}; 
		System.out.println(Arrays.toString(a));
		System.out.println(Arrays.toString(b));
	}
}/*Output:
[1,2,3]
[1,2,3]
*/

第一种方式使用比较受限，只能用于数组定义处；第二、三种方式可以在任何地方使用，甚至是方法调用的内部。例如：你可以将一个String对象的数组，传递给另一个main()方法，以提供参数：

public class DynamicArray{
	public static void main(String[] args){
		Other.main(new String[] {"feddle","de","dum"});
	}
}
class Other{
	public static void main(String[] args){
		for(String s : args){
			System.out.println(s+" ");
		}
	}
}

2. 清理(待完善)

Java有垃圾回收器负责回收无用对象占据的内存资源。特殊情况：假定对象（并非使用new）获得一块特殊的存储空间，垃圾回收器不知道如何释放这块特殊的内存，因此Java允许再类中定义一个名为finalize()的方法。==一旦垃圾回收器准备好释放对象占用的内存空间，首先调用finalize()方法，并在下一次垃圾回收动作时，真正回收对象占用的内存。