java中构造函数的执行顺序

首先假设有如下的一些辅助类，这些类被其他类使用作为静态变量或非静态变量：

public class C {
	public C() {
		System.out.println("C");
	}
}

public class E {
	public E() {
		System.out.println("E");
	}
}

public class F {
	public F() {
		System.out.println("F");
	}
}

public class G {
	public G() {
		System.out.println("G");
	}
}


public class H {
	public H() {
		System.out.println("H");
	}
}

1)继承自Object的类的构造函数的执行顺序：
假设有如下的一个类I,I的定义如下：

public class I {
	public G g = new G();
	public static E statice0 = new E();
	static {
		statice0 = new E();
		System.out.println("判断static执行的顺序");
	}
	public static E statice1;
	public static F f1;
	static {
		System.out.println("测试在static块中执行的顺序1");
		statice1 = new E();
		f1 = new F();
	}
	static {
		System.out.println("测试在static块中执行的顺序2");
		f1 = new F();
		statice1 = new E();
	}
	public static H h = new H();

	public E e;
	{
		System.out.println("aaa");
		e = new E();
	}

	public I(int i) {
		statice0 = new E();
		f1 = new F();
		e = new E();		
	}

	public static void main(String[] args) {
		I i = new I(1);
	}
}

执行结果：
E
E
判断static执行的顺序
测试在static块中执行的顺序1
E
F
测试在static块中执行的顺序2
F
E
H
G
aaa
E
F
H
E
从这个结果来可以知道，从Object派生的类将会按照如下的书序执行：
1、静态变量，如果有静态块的话，则按照静态块中变量new的顺序执行静态变量构造函数。如果没有静态块的话，则按照声明的顺序执行。
2、非静态变量，如果有非静态变量初始化块的话，则按照new的顺序执行构造函数，如果没有初始化块则按照声明的顺序执行。
3、执行构造函数，所有的变量按照new的顺序执行构造函数。

2）如果是从非Object类结成的类
看如下的类：

public class A {
	private static E e = new E();
	private F f = new F();

	public A() {
		System.out.println("A");
	}
}

public class B extends A {
	private static D d = new D();
	private C c = new C();

	public B() {
		System.out.println("B");
	}

	public static void main(String[] args) {
		B b = new B();
	}
}


public class C {
	public static E e = new E();
	public C() {
		System.out.println("C");
	}
}

执行B中的main，则会打印出如下的结果：
E
H
G
D
F
A
E
C
B

首先分析各个类的调用情况，在父类A中有一个E的静态变量，和一个F的非静态变量，B类继承自A，B有一个D的静态变量和C的非静态变量，D中又有一个H的静态变量和g的非静态变量。
从执行得到的结果可以得到如下的结论：
1、首先执行父类中的静态变量的构造函数，在执行构造函数之前执行静态变量的类中的静态变量的构造函数。因此在上例中首先输出：E
2、执行本类的静态变量的构造函数，同上，需要执行静态变量的类中的静态变量的构造函数。上例中会在执行了A中的E的静态变量后执行D的静态变量的构造函数，在此之前需要执行D中的静态变量H的构造函数，然后执行D中的非静态变量G的构造函数。打印出：H G D
3、执行父类中的非静态变量的构造函数。打印出：f
4、执行父类的构造函数。打印出： A
5、执行本类的非静态变量的构造函数，打印出：E C
6、执行本类中的构造函数，按照new的顺序执行构造函数。打印出：B