初始化与清理（4）：成员、构造器初始化

Dear 丶 2023-07-01 12:58 11阅读 0赞

### 一、成员初始化 ###

java尽力保证：所有变量在使用前都能得到恰当的初始化。对于方法的局部变量，java以编译时错误的形式来贯彻这种保证。所以如果写成：

void f() {
    		int i;
    		i++;
    	}

就会得到一条出错信息，告诉你i可能尚未初始化。当然，编译器也可以为i赋一个默认值，但是未初始化的局部变量更有可能是程序员的疏忽，所以采用默认值反而会掩盖这种失误。因此强制程序员提供一个初始值，往往能够帮助找出程序里的缺陷。

要是类的数据成员（即字段）是基本类型，情况就有些不同。类的每个基本类型数据成员保证都会有一个初始值。下面的程序可以验证这类情况，并显示它们的值：

public class InitialValues {
    	byte a;
    	short b;
    	int c;
    	long d;
    	float e;
    	double f;
    	char g;
    	boolean h;
    	InitialValues reference;
    
    	void printInitialValues() {
    		System.out.println("byte:" + a);
    		System.out.println("short:" + b);
    		System.out.println("int:" + c);
    		System.out.println("long:" + d);
    		System.out.println("float:" + e);
    		System.out.println("double:" + f);
    		System.out.println("char:" + g);
    		System.out.println("boolean:" + h);
    		System.out.println("reference:" + reference);
    	}
    
    	public static void main(String[] args) {
    		new InitialValues().printInitialValues();
    	}
    }

可见尽管数据成员的初值（char值为0，所以显示空白）。这样至少不会冒“未初始化变量”的风险了。

在类里定义一个对象引用时，如果不将其初始化，此引用就会获得一个特殊值null。

### 二、指定初始化 ###

如果想为某个变量赋初值，该怎么做呢？有一种很直接的办法，就是在定义类成员变量的地方为其赋值。以下代码片段修改了InitialValues类成员变量的定义，直接提供了初值。

public class InitialValues2 {
    	byte a = 1;
    	short b = 10;
    	int c = 100;
    	long d = 1000;
    	float e = 0.01f;
    	double f = 0.02;
    	char g = 'A';
    	boolean h = true;
    }

也可以用同样的方法初始化非基本类型的对象。如果Depth是一个类，那么可以像下面这样创建一个对象并初始化它：

class Depth {
    
    }
    
    public class Measurement {
    	Depth d = new Depth();
    }

如果没有为d指定初始值就尝试使用它，就会出现运行时错误，告诉你产生了一个异常。

甚至可以通过调用某个方法来提供初值：

public class MethodInit {
    	int i = f();
    
    	int f() {
    		return 11;
    	}
    }

这个方法也可以带有参数，但这些参数必须是已经被初始化了的。因此，可以这样写：

public class MethodInit {
    	int i = f();
    	int j = g(i);
    
    	int f() {
    		return 11;
    	}
    
    	int g(int n) {
    		return n * 10;
    	}
    }

但像下面这样写就不对了：

public class MethodInit {
    	//int j = g(i); Illegal forward reference
    	int i = f();
    
    	int f() {
    		return 11;
    	}
    
    	int g(int n) {
    		return n * 10;
    	}
    }

显然，上述程序的正确性取决于初始化的顺序，而与其编译方式无关。所以，编译器恰当地对“向前引用”发出了警告。

这种初始化方法既简单又直观。但有个限制：类InitialValues的每个对象都会具有相同的初值。有时，这正是所希望的，但有时却需要更大的灵活性。

### 三、构造器初始化 ###

可以用构造器来进行初始化。在运行时刻，可以调用方法或执行某些动作来确定初值，这为编程带来了更大的灵活性。但要牢记：无法阻止自动初始化的进行，它将在构造器被调用之前发生。因此，假如使用下述代码：

public class Counter {
    	int i;
    
    	Counter() {
    		i = 7;
    	}
    }

那么i首先会被置0，然后变成7。对于所有基本类型和对象引用，包括在定义时已经指定初始值的变量，这种情况都是成立的；因此，编译器不会强制你一定要在构造器的某个地方或在使用它们之前对元素进行初始化--因为初始化早已得到了保证。

### 四、初始化顺序 ###

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

class Window {
    	Window(int marker) {
    		System.out.println("Window(" + marker + ")");
    	}
    }
    
    class House {
    	// 构造器之前
    	Window w1 = new Window(1);
    
    	/**
    	 * 构造器
    	 */
    	House() {
    		System.out.println("House()");
    		w3 = new Window(33);
    	}
    
    	// 构造器之后
    	Window w2 = new Window(2);
    
    	void f() {
    		System.out.println("f()");
    	}
    
    	// 最后
    	Window w3 = new Window(3);
    }
    
    public class OrderOfInitialization {
    	public static void main(String[] args) {
    		House h = new House();
    		h.f();
    	}
    }

在House类中，故意把几个Window对象的定义散布到各处，以证明它们全都会在调用构造器或其他方法之前得到初始化。此外，w3在构造器内再次被初始化。

由输出可见，w3这个引用会被初始化两次：一次在调用构造器前，一次在调用期间（第一次引用的对象将被丢弃，并作为垃圾回收）。试想，如果定义了一个重载构造器，它没有初始化w3；同时在w3的定义里也没有指定默认值，那会产生什么后果呢？所以尽管这种方法似乎效率不高，但它的确能使初始化得到保证。

### 五、静态数据的初始化 ###

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

如果想在定义处进行初始化，采取的方法与非静态数据没什么不同。

要想了解静态存储区域是何时初始化的，就请看下面这个例子：

class Bowl {
    	Bowl(int marker) {
    		System.out.println("Bowl(" + marker + ")");
    	}
    
    	void f1(int marker) {
    		System.out.println("f1(" + marker + ")");
    	}
    }
    
    class Table {
    	static Bowl bowl1 = new Bowl(1);
    
    	Table() {
    		System.out.println("Table()");
    		bowl2.f1(1);
    	}
    
    	void f2(int marker) {
    		System.out.println("f2(" + marker + ")");
    	}
    
    	static Bowl bowl2 = new Bowl(2);
    }
    
    class Cupboard {
    	Bowl bowl3 = new Bowl(3);
    	static Bowl bowl4 = new Bowl(4);
    
    	Cupboard() {
    		System.out.println("Cupboard()");
    		bowl4.f1(2);
    	}
    
    	void f3(int marker) {
    		System.out.println("f3(" + marker + ")");
    	}
    
    	static Bowl bowl5 = 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();
    		table.f2(1);
    		cupboard.f3(1);
    	}
    
    	static Table table = new Table();
    	static Cupboard cupboard = new Cupboard();
    }

Bowl类使得看到类的创建，而Table类和Cupboard类在它们的类定义中加入了Bowl类型的静态数据成员。注意，在静态数据成员定义之前，Cupboard类先定义了一个Bowl类型的非静态数据成员b3。

由输出可见，静态初始化只有在必要时刻才会进行。如果不创建Table对象，也不引用Table.b1或Table.b2，那么静态的Bowl b1和b2永远都不会被创建。只有在第一个Table对象被创建（或者第一次访问静态数据）的时候，它们才会被初始化。此后，静态对象不会再次被初始化。

初始化的顺序是先静态对象（如果它们尚未因前面的对象创建过程而被初始化），而后是“非静态”对象。从输出结果中可以观察到这一点。要执行main()（静态方法），必须加载StaticInitialization类，然后其静态域table和cupboard被初始化，这将导致它们对应的类也被加载，并且由于它们也都包含静态的Bowl对象，因此Bowl随后也被加载。这样，在这个特殊的程序中的所有类在main()开始之前就都被加载了。实际情况通常并非如此，因为在典型的的程序中，不会像在本例中所做的那样，将所有的事物都通过static联系起来。

总结一下对象的创建过程，假设有个名为Dog的类：

1.  即使没有显式地使用static关键字，构造器实际上也是静态方法。因此，当首次创建类型为Dog的对象时（构造器可以看成静态方法），或者Dog类的静态方法/静态域首次被访问时，java解释器必须查找类路径，以定位Dog.class文件。
2.  然后载入Dog.class（这将创建一个Class对象），有关静态初始化的所有动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。
3.  当用new Dog()创建对象的时候，首先将在堆上为Dog对象分配足够的存储空间。
4.  这块存储空间会被清零，这就自动地将Dog对象中的所有基本类型数据都设置成了默认值，（对数字来说就是0，对布尔型和字符型也相同），而引用则被设置成了null。
5.  执行所有出现于字段定义处的初始化动作。
6.  执行构造器。

### 六、显式的静态初始化 ###

java允许将多个静态初始化动作组织成一个特殊的“静态子句”（有时也叫做“静态块”）。就下下面这样：

public class Spoon {
    	static int i;
    	static {
    		i = 47;
    	}
    }

尽管上面的代码看起来像个方法，但它实际只是一段跟在static关键字后面的代码。与其他静态初始化动作一样，这段代码仅执行一次：当首次生成这个类的一个对象时，或者首次访问属于那个类的静态数据成员时（即便从未生成过那个类的对象）。例如：

class Cup {
    	Cup(int marker) {
    		System.out.println("Cup(" + marker + ")");
    	}
    
    	void f(int marker) {
    		System.out.println("f(" + marker + ")");
    	}
    }
    
    class Cups {
    	static Cup cup1;
    	static Cup cup2;
    	static {
    		cup1 = new Cup(1);
    		cup2 = new Cup(2);
    	}
    
    	Cups() {
    		System.out.println("Cups()");
    	}
    }
    
    public class ExplicitStatic {
    	public static void main(String[] args) {
    		System.out.println("Inside main()");
    		Cups.cup1.f(99);// （1）
    	}
    	// static Cups cups1=new Cups(); （2）
    	// static Cups cups2=new Cups(); （2）
    }

无论是通过标为（1）的那行代码访问静态的cup1对象，还是把标为（1）的行注释掉，让它去运行标为（2）的那行代码（即解除标为（2）的行的注释），Cups的静态初始化动作都会得到执行。如果把标为（1）和（2）的行同时注释掉，Cups的静态初始化动作就不会进行，就像在输出中看到的那样。此外，激活一行还是两行标为（2）的代码（即解除注释）都无关紧要，静态初始化动作只进行一次。

### 七、非静态实例初始化 ###

java中也有被称为实例初始化的类似语法，用来初始化每一个对象的非静态变量。例如：

class Mug {
    	Mug(int marker) {
    		System.out.println("Mug(" + marker + ")");
    	}
    
    	void f(int marker) {
    		System.out.println("f(" + marker + ")");
    	}
    }
    
    public class Mugs {
    	Mug mug1;
    	Mug mug2;
    	{
    		mug1 = new Mug(1);
    		mug2 = new Mug(2);
    		System.out.println("mug1 & mug2 initialized");
    	}
    
    	Mugs() {
    		System.out.println("Mugs()");
    	}
    
    	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");
    	}
    }

你可以看到实例初始化子句：

{
    		mug1 = new Mug(1);
    		mug2 = new Mug(2);
    		System.out.println("mug1 & mug2 initialized");
    	}

看起来它与静态初始化子句一模一样，只不过少了static关键字。这种语法对于支持“匿名内部类”的初始化是必须的，但是它也使得你可以保证无论调用了哪个显式构造器，某些操作都会发生。从输出中可以看到实例初始化子句是在两个构造器之前执行的。

**如果本文对您有很大的帮助，还请点赞关注一下。**