java类初始化顺序

本篇复习一下关于java类初始化的顺序，温故而知新还是很有道理的。

下面是java类初始化的顺序：

（静态变量、静态初始化块）>（变量、初始化块）>构造器

下面通过几个比较简单的例子来验证。

下面是解决了在单个类中成员初始化的顺序：

    public class InitialOrderTest {                 // 静态变量           public static String staticField = "静态变量";           // 变量           public String field = "变量";                 // 静态初始化块           static {               System.out.println(staticField);               System.out.println("静态初始化块");           }                 // 初始化块           {               System.out.println(field);               System.out.println("初始化块");           }                 // 构造器           public InitialOrderTest() {               System.out.println("构造器");           }                 public static void main(String[] args) {               new InitialOrderTest();           }       }  

运行以上代码，我们会得到如下的输出结果：

1. 静态变量
2. 静态初始化块
3. 变量
4. 初始化块
5. 构造器

下面代码验证了父类和子类的初始化顺序：

    class Parent {           // 静态变量           public static String p_StaticField = "父类--静态变量";           // 变量           public String p_Field = "父类--变量";                 // 静态初始化块           static {               System.out.println(p_StaticField);               System.out.println("父类--静态初始化块");           }                 // 初始化块           {               System.out.println(p_Field);               System.out.println("父类--初始化块");           }                 // 构造器           public Parent() {               System.out.println("父类--构造器");           }       }             public class SubClass extends Parent {           // 静态变量           public static String s_StaticField = "子类--静态变量";           // 变量           public String s_Field = "子类--变量";           // 静态初始化块           static {               System.out.println(s_StaticField);               System.out.println("子类--静态初始化块");           }           // 初始化块           {               System.out.println(s_Field);               System.out.println("子类--初始化块");           }                 // 构造器           public SubClass() {               System.out.println("子类--构造器");           }                 // 程序入口           public static void main(String[] args) {               new SubClass();           }       }  

运行一下上面的代码，结果马上呈现在我们的眼前：

1. 父类--静态变量
2. 父类--静态初始化块
3. 子类--静态变量
4. 子类--静态初始化块
5. 父类--变量
6. 父类--初始化块
7. 父类--构造器
8. 子类--变量
9. 子类--初始化块
10. 子类--构造器

下面验证了静态变量和静态初始化块之间、变量和初始化块之间的先后顺序：

    public class TestOrder {           // 静态变量           public static TestA a = new TestA();                      // 静态初始化块           static {               System.out.println("静态初始化块");           }                      // 静态变量           public static TestB b = new TestB();                 public static void main(String[] args) {               new TestOrder();           }       }             class TestA {           public TestA() {               System.out.println("Test--A");           }       }             class TestB {           public TestB() {               System.out.println("Test--B");           }       }  

运行上面的代码，会得到如下的结果：

1. Test--A
2. 静态初始化块
3. Test--B

代码是引用的别人的（自己比较懒），例子是很好理解。