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.      构造器

这与上文中说的完全符合。那么对于继承情况下又会怎样呢？我们仍然以一段测试代码来获取最终结果：

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.     }  
51.     class Parent {
52.         // 静态变量
53.         public static String p_StaticField = "父类--静态变量";
54.         // 变量
55.         public String p_Field = "父类--变量";
56.         // 静态初始化块
57.         static {
58.             System.out.println(p_StaticField);
59.             System.out.println("父类--静态初始化块");
60.         }
61.         // 初始化块
62.         {
63.             System.out.println(p_Field);
64.             System.out.println("父类--初始化块");
65.         }
66.         // 构造器
67.         public Parent() {
68.             System.out.println("父类--构造器");
69.         }
70.     }
71.     public class SubClass extends Parent {
72.         // 静态变量
73.         public static String s_StaticField = "子类--静态变量";
74.         // 变量
75.         public String s_Field = "子类--变量";
76.         // 静态初始化块
77.         static {
78.             System.out.println(s_StaticField);
79.             System.out.println("子类--静态初始化块");
80.         }
81.         // 初始化块
82.         {
83.             System.out.println(s_Field);
84.             System.out.println("子类--初始化块");
85.         }
86.         // 构造器
87.         public SubClass() {
88.             System.out.println("子类--构造器");
89.         }
90.         // 程序入口
91.         public static void main(String[] args) {
92.             new SubClass();
93.         }
94.     }
95.      

运行一下上面的代码，结果马上呈现在我们的眼前：
1.      父类--静态变量
2.      父类--静态初始化块
3.      子类--静态变量
4.      子类--静态初始化块
5.      父类--变量
6.      父类--初始化块
7.      父类--构造器
8.      子类--变量
9.      子类--初始化块
10.   子类--构造器
现在，结果已经不言自明了。大家可能会注意到一点，那就是，并不是父类完全初始化完毕后才进行子类的初始化，实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。

那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？是否静态变量总是先于静态初始化块，变量总是先于初始化块就被初始化了呢？实际上这取决于它们在类中出现的先后顺序。我们以静态变量和静态初始化块为例来进行说明。

同样，我们还是写一个类来进行测试：

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.     }  
29.     public class TestOrder {
30.         // 静态变量
31.         public static TestA a = new TestA();
32.         
33.         // 静态初始化块
34.         static {
35.             System.out.println("静态初始化块");
36.         }
37.         
38.         // 静态变量
39.         public static TestB b = new TestB();
40.         public static void main(String[] args) {
41.             new TestOrder();
42.         }
43.     }
44.     class TestA {
45.         public TestA() {
46.             System.out.println("Test--A");
47.         }
48.     }
49.     class TestB {
50.         public TestB() {
51.             System.out.println("Test--B");
52.         }
53.     }
54.     

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

大家可以随意改变变量a、变量b以及静态初始化块的前后位置，就会发现输出结果随着它们在类中出现的前后顺序而改变，这就说明静态变量和静态初始化块是依照他们在类中的定义顺序进行初始化的。同样，变量和初始化块也遵循这个规律。

了解了继承情况下类的初始化顺序之后，如何判断最终输出结果就迎刃而解了。