java的初始顺序

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. }  
24.  
25. public class SubClass extends Parent {  
26.     // 静态变量  
27.     public static String s_StaticField = "子类--静态变量";  
28.     // 变量  
29.     public String s_Field = "子类--变量";  
30.     // 静态初始化块  
31.     static {  
32.         System.out.println(s_StaticField);  
33.         System.out.println("子类--静态初始化块");  
34.     }  
35.     // 初始化块  
36.     {  
37.         System.out.println(s_Field);  
38.         System.out.println("子类--初始化块");  
39.     }  
40.  
41.     // 构造器  
42.     public SubClass() {  
43.         System.out.println("子类--构造器");  
44.     }  
45.  
46.     // 程序入口  
47.     public static void main(String[] args) {  
48.         new SubClass();  
49.     }  
50. } 
根据前面讲的可以轻松得到结果了吧
代码二：
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. } 
如果能很好理解java初始化顺序就能解决遇到这类问题。