Java类加载顺序问题

测试java代码块中静态块，初始块，构造块的执行顺序。

定义三个类A，B，C，B继承于A，C继承于B。

代码如下：

package 类加载问题;

public class A {

	static{
		System.out.print("A类静态块1 ");
	}
	
	{
		System.out.print("A类初始块1 ");
	}
	
	public A(){
		System.out.print("A类构造块 ");
	}
	
	static{
		System.out.print("A类静态块2 ");
	}
	
	{
		System.out.print("A类初始块2 ");
	}
	
}

package 类加载问题;

public class B extends A{
	static{
		System.out.print("B类静态块1 ");
	}
	
	{
		System.out.print("B类初始块1 ");
	}
	
	public B(){
		System.out.print("B类构造块 ");
	}
	
	public B(int a){
		System.out.print("B类带参构造块 ");
	}
	
	static{
		System.out.print("B类静态块2 ");
	}
	
	{
		System.out.print("B类初始块2 ");
	}
}

package 类加载问题;

public class C extends B{

	{
		System.out.print("C类初始块1 ");
	}
	
    static{
		System.out.print("C类静态块1 ");
	}
	
	public C(){
		System.out.print("C类构造块 ");
	}
	
	{
		System.out.print("C类初始块2 ");
	}
	
    static{
		System.out.print("C类静态块2 ");
	}
}

最后使用test类对上述类的对象创建时版块的加载顺序进行测试：

代码如下：

package 类加载问题;

public class test {
	
	public static void main(String[] args) {
		A a = new B();
		B b = new B();		
		A c = new A();
		B d = new B(1);
		C e = new C();	
	}

}

依次进行测试

（1）测试A a = new B();目的：测试父类实例化子类对象的类加载顺序

结果：

结论：先依次加载父类静态代码块，再依次加载子类静态代码块，接着依次加载父类初始块，然后执行父类构造块，

再加载子类初始块，最后执行子类构造块

（2）测试B b = new B();目的：测试B类实例化B类对象时是否加载它的父类代码块以及相应类加载顺序

结果：

结论：使用当前类实例化当前类的对象时，会先加载父类的相关代码块（执行顺序跟（1）一致）

（3）测试A c = new A();目的：实验A类实例化A类对象的类加载顺序

结果：

结论：当前类没有父类时，实例化当前类的对象，加载顺序：静态块->初始块->构造方法

（4）测试B d = new B(1);目的：测试B类调用带参构造函数创建对象时，类加载顺序。

结果：

结论：即使父类没有相应参数的构造方法，依旧会加载父类的相关代码块。

（5）测试C e = new C();目的：测试直接使用C类实例化自身创建对象时，加载它的父类以及它自身的代码块顺序

结果：

结论：当实例化的类有父类并且其父类还有父类时，类的加载顺序是：先依次从上到下加载ABC三个类的静态代码块，再依次加载A类的初始块跟构造块，接着依次加载B类的初始块跟构造块，最后加载C类的初始块跟构造块。

总结：

 (1)当前类没有父类时，创建当前类的对象，先调用当前类的静态代码块，再调用初始块，最后调用构造块
 (2)当前类有父类时，先加载父类的静态代码块，再加载当前类的静态代码块，接着加载父类的初始块，调用其构造块，最后加载当前类的初始块，调用其构造块

 (3)如果父类仍有父类时，先将当前类的祖先们的静态代码块自顶向下全部加载一遍，再加载当前类的静态代码块，接着加载当前类祖先们的初始块跟构造块（自顶向下顺序）,最后加载当前类的初始块跟构造块。