Java初始化顺序

成员变量的初始化顺序

• 实例变量在声明处初始化
• 实例变量在实例初始化块中初始化
• 实例变量在构造器中初始化
• 静态变量在声明处初始化
• 静态变量在静态初始块中初始化

将5种初始化代码无规则的分布在程序中，观察执行的顺序

public class InitOrderTest {

    public InitOrderTest(int x, int y) {
        System.out.println("执行构造器···");
        this.x = x;
        this.y = y;
    }

    {
        System.out.println("执行实例初始化块1···");
    }
    private int x;
    private int y = initY();

    {
        System.out.println("执行实例初始化块2···");
        x = initX();
    }

    static {
        System.out.println("执行静态初始化块···");
    }

    private static int staticX;
    private static int staticY = initStaticY();

    static {
        System.out.println("执行静态初始化块2···");
        staticX = initStaticX();
    }

    public int initX() {
        System.out.println("执行实例变量x初始化···");
        return 1;
    }

    public int initY() {
        System.out.println("执行实例变量y初始化···");
        return 1;
    }

    public static int initStaticX() {
        System.out.println("执行静态变量staticX初始化···");
        return 1;
    }

    public static int initStaticY() {
        System.out.println("执行静态变量staticY初始化···");
        return 1;
    }

    public void show() {
        System.out.printf("x=%d,y=%d,staticX=%d,staticY=%d
", x, y, staticX,
                staticY);
    }

    public static void main(String[] args) {

        System.out.println("执行main方法···");
        InitOrderTest iot1 = new InitOrderTest(10, 15);
        InitOrderTest iot2 = new InitOrderTest(20, 25);
        iot1.show();
        iot2.show();

    }

}

运行结果：

分析结果：

1. 当运行InitOrderTest类时，Java虚拟机试图调用该类的main方法时，JVM发现该类尚未加载，因此会首先加载该类，并会执行链接，在链接阶段会为该类的静态方法分配空间，并置为默认值，然后按照初始化在类中的顺序执行静态初始化（只执行一次）。

2. 静态成员的初始化执行完成后，就会执行main方法，创建InitOrderTest类的对象，使用new在堆中为对象分配空间，这时所有的实例变量都设置为默认值。然后执行实例初始化。3种实例初始化方式，首先会按照实例变量在类中声明的初始化顺序执行（这里的顺序指的是初始化在类中声明的顺序，而不是变量在类中声明的顺序），然后执行构造器。

3. 再次创建InitOrderTest类的对象时，不再执行静态初始化。但是每次创建一个对象都要执行一次实例变量初始化。

继承下的初始化

public class SubInitOrderTest extends InitOrderTest {

    private int z = initZ();
    private static int staticZ = initStaticZ();

    public SubInitOrderTest(int x, int y, int z) {
        super(x, y);
        System.out.println("执行子类构造器···");
        this.z = z;
    }

    public int initZ() {
        System.out.println("执行子类实例变量z初始化···");
        return 1;
    }

    public static int initStaticZ() {
        System.out.println("执行子类静态变量staticZ初始化···");
        return 1;
    }

    public static void main(String[] args) {

        new SubInitOrderTest(1, 2, 3);
    }

}

运行结果：

分析执行过程：

1. JVM调用子类的main首先加载、链接并尝试初始化子类，而子类继承了父类，所以在初始化子类之前，需要加载、链接并初始化父类，这是一个递归的过程，直到Object类。所以会首先执行父类中静态变量staticX与staticY和静态初始化块。

2. 当父类与子类静态初始化完成后，执行子类的main方法，创建子类的对象。当子类对象创建时，就会执行实例初始化，而子类继承了父类，因此，首先会执行父类的实例初始化，这也是一个递归的过程，直到object类为止。因而父类的实例初始化会在子类的实例初始化之前完成。即首先执行父类中的实例变量x与y，还有两个实例初始化块与构造器，然后执行子类中实例变量z、实例初始化块与构造器。

总结：

• 初始化的顺序可以简单的总结为先静态，后实例，先父类，后子类。对于静态初始化，按照静态变量声明处初始化与静态初始化块在类中出现的顺序执行。对于实例初始化，按照实例变量声明处初始化与实例初始化块在类中出现的顺序执行，然后执行构造器。
• 当心潜在的向前引用，如果使用一个尚未初始化值的变量值，就可能得到错误的结果
• 在构造器中不要调用可由子类重写的方法，调用private与final的方法才是安全的。
• 对于值为编译时常量的final变量，可以认为这样的变量会最先得到初始化。在程序中无法观察到其默认值，即使向前引用这种类型的变量也是如此。