变量初始化顺序及类的加载顺序

综合：先加载类（静态字段及静态代码块）->(若有则执行主函数main）->默认初始化域-》执行构造方法（隐式初始化域和代码块，再执行构造器的主体）->调用方法

即 如果类还没有被加载： 
1、先执行父类的静态代码块和静态变量初始化，并且静态代码块和静态变量的执行顺序只跟代码中出现的顺序有关。 

2、执行子类的静态代码块和静态变量初始化。 

3默认初始化域

4 执行子类的构造函数，构造函数来执行初始化。其中子类的构造函数第一件事是调用基类的构造函数。（从而从基类到子类递归初始化完毕）第二件事是隐式初始化域和代码块。接着才是执行构造器的主体。

如果类已经被加载： 
则静态代码块和静态变量就不用重复执行，再创建类对象时，只执行与实例相关的变量初始化和构造方法。

代码：子类的构造器中第一件事就是调用基类构造器。

class Classone {
	static {
		System.out.println("Classone静态块");
	}
int t;
	{System.out.println("t自动初始化完毕，结果为："+t);
		System.out.println("Classone非静态块");
	}

	Classone(int i) {
		t=1;
		print("Classone构造器    及t的值  " + t+" i="+i);
	}

}

class Classtwo extends Classone {
	static {
		System.out.println("Classtwo静态块");
	}
int m;
	{System.out.println("m自动初始化完毕，结果为："+m);
		System.out.println("Classtwo非静态块");
	}

	Classtwo(int i) {
		super(i + 1);
		m=5;
		print("Classtwo构造器     及m  " + 5);
	}


}

public class ClassThree extends Classtwo {
	static {
		System.out.println("ClassThree静态块");
	}

	{
		System.out.println("ClassThree非静态块");
	}

	public ClassThree(int i) {
		super(i + 1);
		print("Classthree构造器   " + i);
	}

	public static void main(String[] args) {
//		print();
//		print("--------创建Classone对象");
//		new Classone(1);
		print();
		print("--------创建Classtwo对象");
		new Classtwo(1);
//		print();
//		print("--------创建Classthree对象");
//		new ClassThree(1);
	}

结果：

Classone静态块
Classtwo静态块
ClassThree静态块

--------创建Classtwo对象
t自动初始化完毕，结果为：0
Classone非静态块
Classone构造器    及t的值  1 i=2
m自动初始化完毕，结果为：0
Classtwo非静态块
Classtwo构造器     及m  5

验证在构造器调用之前默认初始化了域：

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

class Glyph {
	void draw() {
		print("Glyph.draw()");
	}

	Glyph() {
		print("Glyph() before draw()");
		draw();
		print("Glyph() after draw()");
	}
}

class RoundGlyph extends Glyph {
	static int t=1;
	private   int radius = 1;
	static {
		print("静态代码块  t=:"+1);
	}
	{
		print("非静态代码块");
	}
	RoundGlyph(int r) {
		super();
		print("初始化radius=:" + radius);
		radius = r;
		print("赋值radius = " + radius);
	}

	void draw() {
		print("默认初始化 radius = " + radius);
	}
}

public class PolyConstructors {
	public static void main(String[] args) {
		new RoundGlyph(5);
	}
}

结果：

静态代码块  t=:1
Glyph() before draw()
默认初始化 radius = 0
Glyph() after draw()
非静态代码块
初始化radius=:1

赋值radius = 5

到此为止，单一类初始化顺序为：

1：加载类（static 域和static代码块）

2：执行main方法（static方法）

3：默认初始化域（代码块没有默认初始化）为0或其他null之类

4：执行构造函数（先隐式初始化 域和代码块，再执行构造器主体）

  继承类初始化顺序：

1：先加载类的成员（先基类再子类）（静态域和静态块）

2 ：再执行main方法（static方法）

3:默认初始化域

4：创建子类的对象时，调用子类构造函数，（递归调用基类构造函数，当基类构造函数执行完毕之后），隐式初始化域和代码块，再执行子类构造函数剩下的部分。

    可知顺序：

1：先加载类的成员（先基类再子类）（静态域和静态块）

2 ：再执行main方法

3：创建子类的对象时，调用子类构造函数，（递归调用基类构造函数，当基类构造函数执行完毕之后），执行子类构造函数剩下的部分。