java类初始化的顺序

先从最简单的说起，我们一般是这样理解的:
先初始化静态 成员/块 然后是构造代码块，最后是构造函数 看一个例子

这是两个类ShunXu 和 Other

public class ShunXu  {


    public ShunXu() {
        System.out.println("构造函数");

    }

    public static Other other = new Other();


    static {
        System.out.println("静态块");
    }
    {
        System.out.println("构造代码块");
    }


    public static void main(String[] args) {
        ShunXu shunXu = new ShunXu();
    }
}

public class Other {

    {
        System.out.println("我是另一个类的构造代码快");
    }
    static {
        System.out.println("我是另一个类的静态块");
    }

}

首先明确一点,静态代码块和静态成员变量是没有先后之分，完全按照代码的顺序执行

执行主函数,首先会装载ShunXu->构造静态成员变量other(other中先执行静态块，后执行构造代码块)->执行静态块->构造代码块->构造函数
因此，输出结果就是

我是另一个类的静态块
我是另一个类的构造代码快
静态块
构造代码块
构造函数

接下来看一个有些奇怪的例子

现在先不管Other，只关注ShunXu

public class ShunXu  {


    public ShunXu() {
        System.out.println("构造函数");

    }

    static ShunXu shunXu = new ShunXu();
    static ShunXu shunXu2 = new ShunXu();


    static {
        System.out.println("静态块");
    }
    {
        System.out.println("构造代码块");
    }


    public static void main(String[] args) {

    }
}

我们在ShunXu内部创建了两个静态ShunXu对象

主函数本身什么也不做，先看看输出结果

构造代码块
构造函数
构造代码块
构造函数
静态块

是不是很神奇，静态块竟然最后执行

其实原因不难分析，可以看出创建两个对象分别调用了两次构造代码块和构造函数，说明构造静态对象的时候并没有执行静态块，也就是说，静态块是由最外层的类来执行的。既然静态块写在了静态成员变量和后面，那么它当然就得等静态成员生成完再执行了

如果将静态块放在最前面

public class ShunXu  {


    public ShunXu() {
        System.out.println("构造函数");

    }



    static {
        System.out.println("静态块");
    }
    {
        System.out.println("构造代码块");
    }

    static ShunXu shunXu1 = new ShunXu();
    static ShunXu shunXu2 = new ShunXu();


    public static void main(String[] args) {

    }
}

那么输出就是

静态块
构造代码块
构造函数
构造代码块
构造函数

这验证我之前的说法:
静态代码块和静态成员变量是没有先后之分，完全按照代码的顺序执行

那如果我们在主函数中再创建一个ShunXu对象呢

public class ShunXu  {


    public ShunXu() {
        System.out.println("构造函数");

    }

    static ShunXu shunXu1 = new ShunXu();
    static ShunXu shunXu2 = new ShunXu();

    static {
        System.out.println("静态块");
    }
    {
        System.out.println("构造代码块");
    }


    public static void main(String[] args) {
        ShunXu xu = new ShunXu();
    }
}

输出为:

构造代码块
构造函数
构造代码块
构造函数
静态块
构造代码块
构造函数

可以看出，这其实并没有违背先静态后非静态的说法

剩下的就是关于父类的说明了

class Parent{
    public Parent(){
        System.out.println("父类构造方法");
    }
    static {
        System.out.println("父类静态块");
    }
}


public class ShunXu  extends Parent{


    public ShunXu() {
        System.out.println("构造函数");

    }

    static ShunXu shunXu1 = new ShunXu();
    static ShunXu shunXu2 = new ShunXu();

    static {
        System.out.println("静态块");
    }
    {
        System.out.println("构造代码块");
    }


    public static void main(String[] args) {
        ShunXu xu = new ShunXu();
    }
}

输出结果为

1父类静态块

2父类构造方法
3构造代码块
4构造函数

5父类构造方法
6构造代码块
7构造函数

8静态块
9父类构造方法
10构造代码块
11构造函数

输出有些多，我们把它们给分割 1 - 7是两个静态成员的构造过程,先对加载其父类 然后调用父类构造方法 然后自身构造 8 - 11就是一个正常的对象的构造过程

说复杂的确有点，想通了其实问题就不大