Java类的初始化顺序

Java代码  

1. public class InitialOrderTest {      
2.      
3.     // 静态变量      
4.     public static String staticField = "静态变量";      
5.     // 变量      
6.     public String field = "变量";      
7.      
8.     // 静态初始化块      
9.     static {      
10.         System.out.println(staticField);      
11.         System.out.println("静态初始化块");      
12.     }      
13.      
14.     // 初始化块      
15.     {      
16.         System.out.println(field);      
17.         System.out.println("初始化块");      
18.     }      
19.      
20.     // 构造器      
21.     public InitialOrderTest() {      
22.         System.out.println("构造器");      
23.     }      
24.      
25.     public static void main(String[] args) {      
26.         new InitialOrderTest();      
27.     }      
28. }   

运行以上代码，我们会得到如下的输出结果： 
1. 静态变量 
2. 静态初始化块 
3. 变量 
4. 初始化块 
5. 构造器 

Java代码  

1. class Parent {      
2.     // 静态变量      
3.     public static String p_StaticField = "父类--静态变量";      
4.     // 变量      
5.     public String p_Field = "父类--变量";      
6.      
7.     // 静态初始化块      
8.     static {      
9.         System.out.println(p_StaticField);      
10.         System.out.println("父类--静态初始化块");      
11.     }      
12.      
13.     // 初始化块      
14.     {      
15.         System.out.println(p_Field);      
16.         System.out.println("父类--初始化块");      
17.     }      
18.      
19.     // 构造器      
20.     public Parent() {      
21.         System.out.println("父类--构造器");      
22.     }      
23. }      

   

Java代码  

1. public class SubClass extends Parent {      
2.     // 静态变量      
3.     public static String s_StaticField = "子类--静态变量";      
4.     // 变量      
5.     public String s_Field = "子类--变量";      
6.     // 静态初始化块      
7.     static {      
8.         System.out.println(s_StaticField);      
9.         System.out.println("子类--静态初始化块");      
10.     }      
11.     // 初始化块      
12.     {      
13.         System.out.println(s_Field);      
14.         System.out.println("子类--初始化块");      
15.     }      
16.      
17.     // 构造器      
18.     public SubClass() {      
19.         System.out.println("子类--构造器");      
20.     }      
21.      
22.     // 程序入口      
23.     public static void main(String[] args) {      
24.         new SubClass();      
25.     }      
26. }     

运行一下上面的代码，结果马上呈现在我们的眼前： 
1. 父类--静态变量 
2. 父类--静态初始化块 
3. 子类--静态变量 
4. 子类--静态初始化块 
5. 父类--变量 
6. 父类--初始化块 
7. 父类--构造器 
8. 子类--变量 
9. 子类--初始化块 
10. 子类--构造器 

Java代码  

1. public class TestOrder {      
2.     // 静态变量      
3.     public static TestA a = new TestA();      
4.           
5.     // 静态初始化块      
6.     static {      
7.         System.out.println("静态初始化块");      
8.     }      
9.           
10.     // 静态变量      
11.     public static TestB b = new TestB();      
12.      
13.     public static void main(String[] args) {      
14.         new TestOrder();      
15.     }      
16. }      
17.      
18. class TestA {      
19.     public TestA() {      
20.         System.out.println("Test--A");      
21.     }      
22. }      
23.      
24. class TestB {      
25.     public TestB() {      
26.         System.out.println("Test--B");      
27.     }      
28. }     

运行上面的代码，会得到如下的结果： 
1. Test--A 
2. 静态初始化块 

3. Test--B 

所以类加载以及初始化的顺序是：类的静态成员初始化分配内存（有父类的先父类，然后自己）->然后main方法执行->类初始化{类非静态成员的初始化，然后执行构造器（有父类的先给父类的非静态成员初始化，然后父类的构造器）}

转自：http://alex09.iteye.com/blog/512440