Java类初始化顺序

先不考虑父类。初始化的一个大原则是：

（1）静态域成员（静态变量和静态代码块）最先；

（2）非静态域成员（成员变量和初始化代码块）先于构造函数；

（3）同是静态域成员或同是非静态域成员，则先后顺序和代码顺序一致

public class InitialOrder {

    private static String staticField = "Static Field Initial";

    private String field = "Field Initial";

    static {
        System.out.println(staticField);
        System.out.println("Static Patch Initial");
    }

    {
        System.out.println(field);
        System.out.println("Field Patch Initial");
    }

    public InitialOrder() {
        System.out.println("Structure Initial ");
    }

    public static void main(String[] argc) {
        new InitialOrder();
    }
}

输出：

Static Field Initial (静态变量) 
Static Patch Initial （静态初始化块） 
Field Initial （变量） 
Field Patch Initial （初始化块） 
Structure Initial （构造器）

然后考虑下父类。在上面的原则下再加一条：

（1）静态域的初始化一定是最先开始的；（当然，已经初始化过了就不再初始化了）

（2）要初始化子类，一定要先初始化父类。

public class ParentInitialOrder {
    private static String staticField = "Parent Static Field Initial";

    private String field = "Parent Field Initial";

    static {
        System.out.println(staticField);
        System.out.println("Parent Static Patch Initial");
    }

    {
        System.out.println(field);
        System.out.println("Parent Field Patch Initial");
    }

    public ParentInitialOrder() {
        System.out.println("Parent Structure Initial ");
    }

}

public class ChildInitialOrder extends ParentInitialOrder {
    private static String staticField = "Child Static Field Initial";

    private String field = "Child Field Initial";

    static {
        System.out.println(staticField);
        System.out.println("Child Static Patch Initial");
    }

    {
        System.out.println(field);
        System.out.println("Child Field Patch Initial");
    }

    public ChildInitialOrder() {
        System.out.println("Child Structure Initial ");
    }

    public static void main(String argv[]) {
        new ChildInitialOrder();
    }
}

Parent Static Field Initial (父类静态变量)
Parent Static Patch Initial (父类静态初始化块)
Child Static Field Initial (子类静态变量)
Child Static Patch Initial (子类静态代码块)
Parent Field Initial (父类变量)
Parent Field Patch Initial (父类初始化块)
Parent Structure Initial (父类构造函数)
Child Field Initial (子类变量)
Child Field Patch Initial (子类初始化块)
Child Structure Initial(子类构造函数)

测试题：

public class InitialOrderTest {
    public static int k = 0;
    public static InitialOrderTest t1 = new InitialOrderTest("t1");
    public static InitialOrderTest t2 = new InitialOrderTest("t2");
    public static int i = print("i");
    public static int n = 99;
    public int j = print("j");

    static {
        print("静态块");
    }

    {
        print("构造块");
    }

    public InitialOrderTest(String str) {
        System.out.println((++k) + ":" + str + "    i=" + i + "    n=" + n);
        ++i;
        ++n;
    }

    public static int print(String str) {
        System.out.println((++k) + ":" + str + "    i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        InitialOrderTest t = new InitialOrderTest("init");
    }
}

答案：

1. j i=0 n=0
2. 构造块 i=1 n=1
3. t1 i=2 n=2
4. j i=3 n=3
5. 构造块 i=4 n=4
6. t2 i=5 n=5
7. i i=6 n=6
8. 静态块 i=7 n=99
9. j i=8 n=100
10. 构造块 i=9 n=101
11. init i=10 n=102