Java中类的加载顺序剖析（常用于面试题）

1.父类静态代码块(静态变量或静态方法，按顺序来执行)；
2.子类静态代码块(静态变量或静态方法，按顺序来执行)；
3.父类非静态代码块；
4.父类构造函数；
5.子类非静态代码块；
6.子类构造函数；

这其实是去年校招时我遇到的一道阿里巴巴的笔试题(承认有点久远了-。-)，嗯，如果我没记错的话，当时是作为Java方向的一道选做大题。当然题意没有这么直白，题目只要求你写出程序运行后所有System.out.println的输出结果，其中程序是题目给的，而各个System.out.println的执行顺序不同会导致最后程序输出的结果也不同。

具体的题目我肯定记不清，不过我们可以换个直接的问法，如果类A和类B中有静态变量，静态语句块，非静态变量，非静态语句块，构造函数，静态方法，非静态方法，同时类A继承类B，请问当实例化A时，类内部的加载顺序是什么?

当时我也是一头雾水，事后我就自己写了一个小Demo，这才知道了类内部的实际加载顺，测试代码如下：

Class B:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

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( "Class 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 ; } }

Class A:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

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 void aDisplay(){      i++;      System.out.println( "Class A:static void aDisplay(): " + "i=" +i+ ",j=" +j);      return ; } //静态方法 public static void aTest(){      i++;      System.out.println( "Class A:static void aTest():    " + "i=" +i);      return ; } }

Class ClassLoading :

?

1 2 3 4 5 6 7

public class ClassLoading {             public static void main (String args[]) {          A a= new A();          a.aDisplay();      } }

程序运行结果如图：

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

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

OK，今天就总结到这里了，如果有地方说的不好或有错误的地方，欢迎大家指出，定当改正，谢谢。

===================================================

class SingleTon {

public static int count1;
    public static int count2 = 0;


//结果集
//    count1=1
//    count2=1
    
    private static SingleTon singleTon = new SingleTon();
    
//    public static int count1;
//    public static int count2 = 0;
    
//结果集
//  count1=1
//  count2=0


   //顺序放的不同，导致的结果不同
    
    private SingleTon() {
        count1++;
        count2++;
    }
 
    public static SingleTon getInstance() {
        return singleTon;
    }
}
 
public class Test {
    public static void main(String[] args) {
        SingleTon singleTon = SingleTon.getInstance();
        System.out.println("count1=" + singleTon.count1);
        System.out.println("count2=" + singleTon.count2);
    }
}