Java类初始化顺序

一、静态变量与静态初始化块

在Java中，静态变量和静态初始化块的初始化优先级高于普通变量和代码块，它们在类被加载时就被初始化。

public class StaticExample {
    static int s = 1;
    static{
        s++;
    }
    public static void main(String[] args){
        System.out.println(s); //输出结果：2
    }
}

在上述代码中，当类被加载时，静态变量s会被初始化为1，接着静态初始化块中的代码会被执行，将s的值加1，因此输出结果为2。

静态变量和静态初始化块的初始化顺序取决于它们在代码中的出现顺序。

public class StaticExample {
    static int s = 1;
    static{
        System.out.println(s); //输出结果：1
    }
    static int t = 2;
    static{
        System.out.println(s); //输出结果：1
        System.out.println(t); //输出结果：2
    }
}

在上述代码中，当类被加载时，s先被初始化为1，然后执行静态初始化块中的代码。接着t被初始化为2，最后又执行静态初始化块中的代码。

二、成员变量与初始化块

Java中成员变量可以在声明时进行初始化，也可以在初始化块中进行初始化。

public class FieldExample {
    int x = 1;
    {
        x++;
    }
    int y = 2;
    {
        System.out.println(x); //输出结果：2
        System.out.println(y); //输出结果：2
    }
}

在上述代码中，当类被实例化时，成员变量x先被初始化为1，然后执行初始化块中的代码，将x的值加1。接着y被初始化为2，最后又执行初始化块中的代码。

成员变量和初始化块的初始化顺序取决于它们在代码中的出现顺序。

三、构造方法

构造方法在类被实例化时被调用，可以对成员变量进行初始化操作。

public class ConstructorExample {
    int x;
    int y;
    int z;
    public ConstructorExample(){
        x++;
        y = 2;
    }
    public ConstructorExample(int z){
        x = 2;
        y++;
        this.z = z;
    }
    public static void main(String[] args){
        ConstructorExample ce1 = new ConstructorExample();
        System.out.println(ce1.x); //输出结果：1
        System.out.println(ce1.y); //输出结果：2
        System.out.println(ce1.z); //输出结果：0
        ConstructorExample ce2 = new ConstructorExample(3);
        System.out.println(ce2.x); //输出结果：2
        System.out.println(ce2.y); //输出结果：1
        System.out.println(ce2.z); //输出结果：3
    }
}

在上述代码中，构造方法可以有不同的参数，根据参数的不同来对成员变量进行不同的初始化操作。

构造方法的初始化顺序是先执行父类的构造方法，再执行自己的构造方法，最后执行成员变量和初始化块。

四、继承中的初始化顺序

在继承关系中，子类的初始化顺序依赖于它父类的初始化顺序。

public class Parent {
    static int s = 1;
    int x = 1;
    {
        x++;
    }
    public Parent(){
        x++;
    }
    static{
        s++;
    }
}
public class Child extends Parent {
    static int t = 2;
    int y = 2;
    {
        y++;
    }
    public Child(){
        y++;
    }
    static{
        t++;
    }
    public static void main(String[] args){
        System.out.println(s); //输出结果：2
        System.out.println(t); //输出结果：3
        Child c = new Child();
        System.out.println(c.x); //输出结果：3
        System.out.println(c.y); //输出结果：4
    }
}

在上述代码中，当类被加载时，先执行Parent类的静态块并将s的值加1，接着执行Child类的静态块并将t的值加1。

在实例化时，先执行父类的构造方法，父类的成员变量和初始化块被初始化，然后执行子类的构造方法，子类的成员变量和初始化块被初始化。

成员变量和初始化块的初始化顺序取决于它们在代码中的出现顺序。同时，当子类的构造方法调用父类的构造方法时，父类的构造方法会先被执行。