Java 初始化顺序

Java 初始化顺序

1、初始化顺序

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

class Window {
	Window(int marker) {
		System.out.println("Window(" + marker+ ")");
	}
}
class House {
	Window w1 = new Window(1); // before constructor
	
	House() {
		System.out.println("House()");
		w2 = new Window(33);
	}
	
	Window w2 = new Window(2); // after constructor
	
	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();
	}
}

结果为:

Window(1)
Window(2)
Window(3)
House()
Window(33)
f()

在House类中,故意把几个Window对象的定义散布到各处,以证明它们全部会在调用构造器或者其它方法之前得到初始化。

此外,w3在构造器内再次被初始化。

由输出可见,w3这个引用会被初始化两次:一次在调用构造器前,一次在调用期间(第一次引用的对象将被丢弃,并作为垃圾回收)。

2、静态数据初始化

    无论创建多少个对象,静态数据都只占用一份存储区域。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()");
		bowl1.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(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)
    Bowl类使得看到类的创建,而Table类和Cupboard类在它们的类定义中加入了Bowl类型的静态数据成员。注意,在静态数据成员定义之前,Cupboard类先定义了一个Bowl类型的非静态数据成员b3。
    由输出可见,静态初始化只有在必要时刻才会进行。如果不创建Table对象,也不引用Table.b1或Table.b2,那么静态的Bowl b1和b2永远都不会被创建。只有在第一个Table对象被创建(或者第一次访问静态数据)的时候,它们才会被初始化。此后,静态对象不会再次被初始化。
初始化的顺序是先静态对象(如果它们尚未因前面的对象创建过程而被初始化),而后是"非静态"对象。从输出结果中可以观察到这一点。
要执行main()(静态方法),必须加载StaticInitialization类,然后其静态域table和cupboard被初始化,这将导致它们对应的类也被加载,
并且由于它们也都包含静态的Bowl对象,因此Bowl随后也被加载。这样,在这个特殊的程序中的所有类在main()开始之前就都被加载了。
总结一下对象的创建过程,假设有个名为Dog的类:
  1. 即使没有显式地使用static关键字,构造器实际上也是静态方法。因此,当首次创建类型为Dog的对象时(构造器可以看成静态方法),或者Dog类的静态方法/静态域首次被访问时,Java解释器必须查找类路径,以定位Dog.class文件。
  2. 然后载入Dog.class,有关静态初始化的所有动作都会执行。因此,静态初始化只在Class对象首次加载的时候进行一次。
  3. 当用new Dog()创建对象的时候,首先将在堆上为Dog对象分配足够的存储空间。
  4. 这块存储空间会被清零,这就自动地将Dog对象中的所有基本类型数据都设置成了默认值(对数字来说就是0,对布尔型和字符型也相同),而引用则被设置成了nul。
  5. 执行所有出现于字段定义处的初始化动作。
  6. 执行构造器。

3、继承初始化

    了解包括继承在内的初始化全过程,以对所发生的一切有个全局性的把握,是很有益的。请看下例:
class Insect {
	private int i = 9;
	protected int j;
	
	Insect() {
		System.out.println("i = " + i + ", j = " + j);
		j = 39;
	}
	
	private static int x1 = printInt("static Insect.x1 initialized");
			
	static int printInt(String s) {
		System.out.println(s);
		return 47;
	}
}
public class Beetle extends Insect{
	private int k = printInt("Beetle.k initialized");
	private static int x2 = printInt("static Beetle.x2 initialized");
	public Beetle() {
		System.out.println("k = " + k);
		System.out.println("j = " + j);
 	}
	public static void main(String[] args) {
		System.out.println("Beetle constructor");
		Beetle beetle =  new Beetle();
	}
}
     结果为:   
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 47
j = 39
       在Beetle上运行Java时,所发生的第一件事情就是试图访问Beetle.main()(一个static方法),于是加载器开始启动并找出Beetle类的编译代码(在名为Beetle.class的文件之中)。在对它进行加载的过程中,编译器注意到它有一个基类(这是由关键字extends得知的),于是它继续进行加载。不管你是否打算产生一个该基类的对象,这都要发生。
    如果该基类还有其自身的基类,那么第二个基类就会被加载,如此类推。接下来,根基类中的static初始化(在此例中为Insect)即会被执行,然后是下一个导出类,以此类推。这种方法很重要,因为导出类的static初始化可能会依赖于基类成员能否被正确初始化。
    至此为止,必要的类都已加载完毕,对象就可以被创建了。首先,对象中所有的基本类型都会被设为默认值,对象引用被设为null--这是通过将对象内存设为二进制零值而一举生成的。然后,基类的构造器会被调用。在本例中,它是被自动调用的。但也可以用super来指定对基类构造器的调用。基类构造器和导出类的构造器一样,以相同的顺序来经历相同的过程。在基类构造器完成之后,实例变量按其次序被初始化。最后,构造器的其余部分被执行。









你可能感兴趣的:(Java,基础)