Java成员初始化顺序

1. 初始化顺序

在类的内部，变量定义的先后顺序决定了初始化的顺序。即使变量散布于方法定义之间，他们仍会在任何方法（包括构造器）被调用之前初始化。

2. 静态成员初始化顺序

　　1⃣️初始化类的静态成员或者静态块，静态初始化只在Class对象首次加载的时候进行一次。

　　2⃣️执行构造器

　　3⃣️初始化非静态成员

例如：

public class Animal {
    
    public Animal(String name) {
        System.out.println("Animal [" + name + "]");
    }
    
    public void m1() {
        System.out.println("Animal.m1 is invoked.....");
    }

}

public class Car {
    public Car(String name) {
        System.out.println("Car [" + name + "]");
    }
    public void m1() {
        System.out.println("Car.m1 is invoked.....");
    }
}

public class Table {
    static Animal a1 = new Animal("a1");
    
    Table() {
        a1.m1();
    }
    
    public void m1() {
        System.out.println("Table.m1 is invoked.....");
    }
    
    static Car c1 = new Car("c1");
}

public class StaticInitialization {
    static Table t1 = new Table();
    static Table t2 = new Table();
    
    public static void main(String[] args) {
        System.out.println(t1.a1 == t2.a1);
    }
}

输出结果：
Animal [a1]
Car [c1]
Animal.m1 is invoked.....
Animal.m1 is invoked.....
true

由输出结果，可以看出t1和t2的成员a1是同一个对象，说明Table类的静态成员a1，c1只初始化了一次。

3. 非静态实例初始化

Java中也有被称为实例初始化的类似语法，用来初始化每一个对象的非静态变量。同样，初始化是发生在构造器之前的。

例如：

public class Mug {
    Mug(int marker) {
        System.out.println("Mug[" + marker + "]");
    }
}

public class Mugs {
    
    Mug mug1;
    Mug mug2;
　　static Mug mug3;
    //非静态成员初始化
    {
        mug1 = new Mug(1);
        mug2 = new Mug(2);
    }
    static {
　　　　mug3 = new Mug(3);
　　}

    Mugs() {
        System.out.println("Mugs is created...");
    }

}

public static void main(String[] args) {
        Mugs mugs = new Mugs();
    }
输出结果：
Mug[3]
Mug[1]
Mug[2]
Mugs is created..

从输出结果可以看出，实例初始化子句是在静态代码块之后，构造器之前执行的。

这种语法对于支持”匿名内部类“的初始化是必须的。