Java类的加载顺序

问题

        昨天有人问我一个类中有静态方法，有静态代码块，普通代码块，构造函数，普通方法，静态方法，那么它们的加载顺序是什么？如果有之类继承该类，也有如上的方法，那么加载顺序又是如何？

实例1

      普通方法StaticVar

     

[java] view plain copy

 

1. package org.andy.test;  
2.   
3. /**   
4.  * @author andy   
5.  * @version：2015-2-4 上午10:52:32   
6.  *  
7.  *   
8.  */  
9.   
10. public class StaticVar {  
11.    public StaticVar() {    
12.        System.out.println("----StaticVar-----");  
13.    }  
14. }  

   测试加载方法OrderLoad

[java] view plain copy

 

1. package org.andy.test;  
2.   
3. /**   
4.  * @author andy   
5.  * @version：2015-2-4 上午10:33:48   
6.  *  
7.  *   
8.  */  
9.   
10. public class OrderLoad {  
11.   
12.       
13.     static{  
14.         System.out.println("----OrderLoad静态代码块-----");  
15.     }  
16.       
17.     private static StaticVar staticVar = new StaticVar();  
18.       
19.     {  
20.         System.out.println("----OrderLoad代码块-----");  
21.     }  
22.       
23.     public OrderLoad(){  
24.         System.out.println("----OrderLoad构造函数-----");  
25.         System.out.println(" ");  
26.     }  
27.       
28.     public static void staticFunction(){  
29.         System.out.println("----OrderLoad静态方法-----");  
30.     }  
31.       
32.     public  void normalFunction(){  
33.         System.out.println("----OrderLoad普通方法-----");  
34.     }  
35.     /** 
36.      * @param args 
37.      */  
38.     public static void main(String[] args) {  
39.         // TODO Auto-generated method stub  
40.         OrderLoad staticVar = new OrderLoad();  
41.         OrderLoad.staticFunction();  
42.         staticVar.normalFunction();  
43.     }  
44.   
45. }  

运行结果如下：

    

   加载顺序是：

        静态代码块-----静态方法--------普通代码块-------构造方法-----------调用的方法（包括静态方法和非静态方法，按调用顺序）

实例2

    子类OrderLoadChild实现父类OrderLoad

   

[java] view plain copy

 

1. package org.andy.test;  
2.   
3. /**   
4.  * @author andy   
5.  * @version：2015-2-4 上午11:33:51   
6.  *  
7.  *   
8.  */  
9.   
10. public class OrderLoadChild extends OrderLoad {  
11.   
12.     static {  
13.         System.out.println("----OrderLoadChild静态代码块-----");  
14.     }  
15.       
16.     private static StaticVar staticVar = new StaticVar();  
17.       
18.     {  
19.         System.out.println("----OrderLoadChild代码块-----");  
20.     }  
21.       
22.     public OrderLoadChild(){  
23.           
24.         System.out.println("----OrderLoadChild构造函数-----");    
25.         System.out.println(" ");  
26.     }  
27.       
28.     /** 
29.      * @param args 
30.      */  
31.     public static void main(String[] args) {  
32.         // TODO Auto-generated method stub  
33.         OrderLoadChild orderLoadChild = new OrderLoadChild();  
34.     }  
35.   
36. }  

运行结果如下：

加载顺序是：

        父类静态块-----父类静态常量-------子类静态块----------子类静态常量----------父类普通代码块------------父类构造方法------------子类代码块------------子类构造方法

类的加载顺序

1、静态代码块/静态成员

         静态代码块/静态成员最先加载。

         静态代码块/静态成员顺序按照代码书写先后顺序加载。

         如父类有静态代码块/静态成员，先调用父类静态代码块/静态成员（Object最优先），再一次加载本类的静态代码块/静态成员。

2、普通代码块/非静态成员

         同一类中普通代码块/非静态成员顺序在静态代码块/静态成员加载之后。

         同一类中多段普通代码块/非静态成员加载顺序按照代码书写先后加载。

         如父类有普通代码块/非静态成员，现在加载父类的普通代码块/非静态成员，在加载子类的普通代码块/非静态成员。

3、构造方法

       同一类中构造方法次于代码块之后加载。

       同一类中如果有多个构造方法，按照实例时所调用的加载。

       先加载父类的构造方法，在加载子类的构造方法。

       子类的普通代码块/非静态成员加载顺序低于父类构造函数的加载顺序。

       

4、静态方法/普通方法

        调用时才加载。

总结：

   先加载父类的静态代码块/静态成员（父类中中都有或有多个有，按书写顺序） -------------  加载子类的静态代码块/静态成员（字类中都有或有多个，按书写顺序）---------父类的普通代码块/非静态成员（父类中中都有或有多个有，按书写顺序）------------父类的构造方法-----------------子类的普通代码块/非静态成员（字类中都有或有多个，按书写顺序）-----------子类的构造方法