Java类加载顺序，静态代码块和构造代码块

 构造代码块

随着对象的加载而加载,创建对象的时候执行
1、构造代码块在创建对象时被调用，每次创建对象都会调用一次
2、构造代码块优先于构造函数执行，同时构造代码块的运行依赖于构造函数
3、构造代码块在类中定义

静态代码块

静态块：用static申明，JVM加载类时执行，仅执行一次

静态代码随着类的加载而加载,
调用类的时候执行,
不需要实例化类就能被加载.
常用来执行类属性的初始化,
不能访问普通变量

class AA {
    //随着对象的加载而加载,创建对象的时候执行
    //1、构造代码块在创建对象时被调用，每次创建对象都会调用一次
    //2、构造代码块优先于构造函数执行，同时构造代码块的运行依赖于构造函数
    //3、构造代码块在类中定义
    {
        System.out.println("构造代码块");
    }
    //静态代码随着类的加载而加载,
    // 调用类的时候执行,
    // 不需要实例化类就能被加载.
    // 常用来执行类属性的初始化,
    //不能访问普通变量
    static {
        System.out.println("静态代码");
    }

    public static void main(String[] args) {
        System.out.println("main");

        AA aa = new AA();//把这个注释掉,构造代码块就不会执行
    }
}

执行顺序为：静态代码块-----main------构造代码块

将new AA();注销则构造代码块不会执行。

---

这样的情况 首先会执行静态类,然后创建实例化对象,执行构造代码块

class AA {
    //这样的情况 首先会执行静态类,然后创建实例化对象,执行构造代码块
    static public AA a = new AA();
    {
        System.out.println("构造代码块,再执行静态代码");
    }
    static {
        System.out.println("静态代码");
    }

    public static void main(String[] args) {
        System.out.println("main");

        AA aa = new AA();
    }
}
输出：

构造代码块,再执行静态代码
静态代码
main
构造代码块,再执行静态代码

 最终理解

1. 有继承的先执行基类

2. 静态类实例化早于静态代码块

3. 静态类实例化，后续接着执行构造代码块和构造函数

3. 静态代码块只执行一次

4. 静态代码块执行早于main函数

5. 子类实例化的时候，执行基类初始化

/**
 * @运行结果：
 * A的构造代码块
 * A的构造方法
 * A的静态代码块
 * A的构造代码块
 * A的构造方法
 * A的构造代码块
 * A的构造方法
 * B的构造代码块
 * B的构造函数
 * B的静态代码块
 * main
 * A的构造代码块
 * A的构造方法
 * A的构造代码块
 * A的构造方法
 * B的构造代码块
 * B的构造函数
 */
class ClassA{
    public static ClassA classA = new ClassA();//1 静态基类实例化对象，运行基类，输出（A的构造代码块，A的构造方法）
    {
        System.out.println("A的构造代码块");//生成classA对象时执行
    }
    static {
        System.out.println("A的静态代码块");//2.输出A的静态代码块，只执行一次
    }
    public ClassA(){
        System.out.println("A的构造方法");//生成ClassA对象时执行
    }
}

class ClassB extends ClassA{
    public ClassA classA = new ClassA();//生成ClassB对象时执行，输出（A的构造代码块，A的构造方法）
    public static ClassB classB = new ClassB();//3. 静态子类实例化对象，要牵扯到基类。输出（基类的：A的构造代码块，A的构造方法，生成ClassB对象时执行的：A的构造代码块，A的构造方法，后续执行：B的构造代码块，B的构造函数）
    {
        System.out.println("B的构造代码块");
    }
    static {
        System.out.println("B的静态代码块");// 4. B的静态代码块，只执行一次
    }
    public ClassB(){
        System.out.println("B的构造函数");
    }

    public static void main(String[] args) {
        System.out.println("main");//5 输出main
        new ClassB();//6 输出输出（基类的：A的构造代码块，A的构造方法，生成ClassB对象时执行的：A的构造代码块，A的构造方法，后续执行：B的构造代码块，B的构造函数
    }
}