java 的初始化顺序

首先看一段代码来考考大家，请大家在不运行程序的情况下，输出以下代码的结果：

class Insect {
	int i = 9;
	int j;

	Insect() {
		prt("i = " + i + ", j = " + j);
		j = 39;
	}

	static int x1 = prt("static Insect.x1 initialized");

	static int prt(String s) {
		System.out.println(s);
		return 47;
	}
}

public class Test extends Insect {
	int k = prt("Beetle.k initialized");

	Test() {
		prt("k = " + k);
		prt("j = " + j);
	}

	static int x2 = prt("static Beetle.x2 initialized");

	static int prt(String s) {
		System.out.println(s);
		return 63;
	}

	public static void main(String[] args) {
		prt("Beetle constructor");
		Test b = new Test();
	}
}

代码的结果：

static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 63
j = 39

如果你的结果是正确的，那我真是很佩服了……

对Test运行Java 时，发生的第一件事情是装载程序到外面找到那个类。在装载过程中，装载程序注意它
有一个基础类（即extends 关键字要表达的意思），所以随之将其载入。无论是否准备生成那个基础类的一
个对象，这个过程都会发生（请试着将对象的创建代码当作注释标注出来，自己去证实）。 
若基础类含有另一个基础类，则另一个基础类随即也会载入，以此类推。接下来，会在根基础类（此时是
Insect）执行 static 初始化，再在下一个衍生类执行，以此类推。保证这个顺序是非常关键的，因为衍生类
的初始化可能要依赖于对基础类成员的正确初始化。 
此时，必要的类已全部装载完毕，所以能够创建对象。首先，这个对象中的所有基本数据类型都会设成它们
的默认值，而将对象句柄设为null。随后会调用基础类构建器。在这种情况下，调用是自动进行的。但也完
全可以用super 来自行指定构建器调用（就象在Test()构建器中的第一个操作一样）。基础类的构建采用
与衍生类构建器完全相同的处理过程。基础顺构建器完成以后，实例变量会按本来的顺序得以初始化。最
后，执行构建器剩余的主体部分。 

补充：

class Father{
	Father(){
		System.out.println("father run!");
	}
}
class Son extends Father{
	Son(){
		System.out.println("son run!");
	}
}
public class Demo {
	public static void main(String[] args) {
		new Son();
		//father run!
		//son run!
	}
}

在子类构造对象时，访问子类构造函数时，父类也运行。为什么哪？
在子类构造函数中第一行有一个默认的隐式语句：super();并且子类实例化过程中，子类所有的构造函数默认都会访问父类中的空参数的构造函数，如果父类中没有定义空参的构造函数，那么子类构造函数必须用super显式调用父类中的哪个构造函数。 
Son(){
super(4);
System.out.println("son run!");
}
为什么子类实例化过程中要调用父类的构造函数？

class Father{
	int num;
	Father(){
		num=10;
	}
}
public class Son extends Father{
	Son(){
		System.out.println(num);
	}
	public static void main(String[] args) {
		new Son();//10
	}
}

那是因为子类继承了父类，获取到了父类中的内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。Super语句要定义在子类构造函数的第一行，因为父类的初始化动作要先完成。
如果子类构造函数中如果使用this调用了本类构造函数时，那么子类的此构造函数中的super就没有了，因为super和this都只能定义第一行。所以只能有一个，保是可以保证的是，子类中肯定会有其它的构造函数访问父类的构造函数。

class Father{
	int num;
	Father(){
	}
}
public class Son extends Father{
	Son(){//这个调用父类构造函数
	}
	Son(int num){
		this();//此时有this情形
	}
	public static void main(String[] args) {
		new Son(20);//20
	}
}

class Father{
	int num=10;
	Father(){
		show();
	}
	public void show(){
		System.out.println("Father run "+num);
	}
}
public class Son extends Father{
	int num=20;
	Son(){
		show();
	}
	public void show(){
		System.out.println("son run "+num);
	}
	public static void main(String[] args) {
		new Son();
		
	}
}
//son run 0
//son run 20

一个对象实例化过程Person p=new Person()：
1. JV M会读取指定路径下Person.class文件，并加载进内存，并会先加载Person的父类（如果有直接父类）;
2. 在堆内存中为此对象开辟空间，分配地址。
3. 并在对象空间中，对对象中的属性进行默认初始化。
4. 调用对应的构造函数进行初始化。
5. 在构造函数中，第一行会先调用父类的构造函数进行初始化
6. 父类初始化完毕，再对子类的属性进行显式初始化
7. 再进行子类构造函数的特定初始化
8. 初始化完毕，将地址值赋给引用变量