类加载顺序实例解析

1、虚拟机在首次加载Java类时，会对静态初始化块、静态成员变量、静态方法进行一次初始化
 2、只有在调用new方法时才会创建类的实例
 3、类实例创建过程：按照父子继承关系进行初始化，首先执行父类的初始化块部分，然后是父类的构造方法；再执行本类继承的子类的初始化块，最后是子类的构造方法
 4、类实例销毁时候，首先销毁子类部分，再销毁父类部分

下面通过一个例子来理解关于java类的加载顺序

B.java

package com.test;

/**
 * Created by HJS on 2017/9/13.
 */
public class B {
    //静态变量
    static int i=1;
    //静态语句块
    static {
        System.out.println("Class B1:static blocks"+i);
    }
    //非静态变量
    int j=1;
    //静态语句块
    static {
        i++;
        System.out.println("Class B2:static blocks"+i);
    }
    //构造函数
    public B(){
        i++;
        j++;
        System.out.println("constructor B:"+"i="+i+",j="+j);
    }
    //非静态语句块
    {
        i++;
        j++;
        System.out.println("Class B:common blocks"+"i="+i+",j="+j);
    }
    //非静态方法
    public void bDisplay(){
        i++;
        System.out.println("Clalss B:static void bDisplay():"+"i="+i+",j="+j);
        return;
    }
    //静态方法
    public static void btest(){
        i++;
        System.out.println("Class B:static void bTest():"+"i="+i);
        return;
    }
}

A.java

package com.test;

/**
 *
 * Created by HJS on 2017/9/13.
 */
public class A extends B {
    //静态变量
    static int i=1;
    //静态语句块
    static {
        System.out.println("Class A1:static blocks"+i);
    }
    //非静态变量
    int j=1;
    //静态语句块
    static {
        i++;
        System.out.println("Class A2: static blocks"+i);
    }
    //构造函数
    public A(){
        super();
        i++;
        j++;
        System.out.println("constructor A:"+"i="+i+",j="+j);
    }
    //非静态语句块
    {
        i++;
        j++;
        System.out.println("Class A: common blocks"+"i="+i+",j="+j);
    }
    //非静态方法
    public static void aDisplay(){
        i++;
        System.out.println("Class A: static void aDisplay()"+"i="+i);
        return;
    }
    //静态方法
    public static void aTest(){
        i++;
        System.out.println("Class A:static void aTest()"+"i="+i);
        return;
    }
}

ClassLoading.java

package com.test;

/**
 * Created by HJS on 2017/9/13.
 */
public class ClassLoading {
    public static void main(String args[]){
        A a=new A();

        a.aDisplay();
    }
}

运行结果：

Class B1:static blocks1
Class B2:static blocks2
Class A1:static blocks1
Class A2: static blocks2
Class B:common blocksi=3,j=2
constructor B:i=4,j=3
Class A: common blocksi=3,j=2
constructor A:i=4,j=3
Class A: static void aDisplay()i=5

总结：

通过上述示图，我们可以比较清晰的看出java类的整个加载过程。

1.若要加载类A，则先加载执行其父类B(Object)的静态变量以及静态语句块(执行先后顺序按排列的先后顺序)。
2.然后再加载执行类A的静态变量以及静态语句块。(并且1、2步骤只会执行1次)
3.若需实例化类A，则先调用其父类B的构造函数,并且在调用其父类B的构造函数前,依次先调用父类B中的非静态变量及非静态语句块.最后再调用父类B中的构造函数初始化。
4.然后再依次调用类A中的非静态变量及非静态语句块.最后调用A中的构造函数初始化。( 并且3、4步骤可以重复执行)
5.而对于静态方法和非静态方法都是被动调用,即系统不会自动调用执行,所以用户没有调用时都不执行,主要区别在于静态方法可以直接用类名直接调用(实例化对象也可以),而非静态方法只能先实例化对象后才能调用。