Java 类加载初始化过程

1. 类的静态变量和静态初始化块是按照从上到下的顺序执行的。

public class Demo {
    static {
        System.out.println("静态初始化类Demo");
    }
    public static void main(String[] args) {
        System.out.println("开始执行main方法");
        A a = new A();
        System.out.println(A.w);
    }
}

class A {
    public static int w = 100;
    static {
        System.out.println("静态初始化类A");
        w = 200;
    }
    public A(){
        System.out.println("创建A的对象");
    }
}

静态初始化类Demo
开始执行main方法
静态初始化类A
创建A的对象
200

public class Demo {
    static {
        System.out.println("静态初始化类Demo");
    }
    public static void main(String[] args) {
        System.out.println("开始执行main方法");
        A a = new A();
        System.out.println(A.w);
    }
}

class A {
    static {
        System.out.println("静态初始化类A");
        w = 200;
    }
    //为什么可以后声明，因此静态变量在编译阶段就已经明确，所以声明和初始化可以在编码顺序上颠倒。
    public static int w = 100;

    public A(){
        System.out.println("创建A的对象");
    }
}

静态初始化类Demo
开始执行main方法
静态初始化类A
创建A的对象
100

2. 先初始化父类再初始化子类，并且静态初始化只会执行一次

public class Demo {
    static {
        System.out.println("静态初始化类Demo");
    }
    public static void main(String[] args) {
        System.out.println("开始执行main方法");
        A a = new A();
        System.out.println(A.w);

        A a2 = new A();
    }
}

class A extends A_Father{
    public static int w = 100;
    static {
        System.out.println("静态初始化类A");
        w = 200;
    }

    public A(){
        System.out.println("创建A的对象");
    }
}

class A_Father{
    public static int h = 300;
    static {
        System.out.println("静态初始化类A_Father");
    }
    public A_Father(){
        System.out.println("创建A_Father对象");
    }
}

静态初始化类Demo
开始执行main方法
静态初始化类A_Father
静态初始化类A
创建A_Father对象
创建A的对象
200
创建A_Father对象
创建A的对象

3. 类的主动引用一定会发生类的初始化

• new 一个类的对象；
• 调用类的静态成员（除了final 常量）和静态方法；

public class Demo {
    static {
        System.out.println("静态初始化类Demo");
    }
    public static void main(String[] args) {
        System.out.println("开始执行main方法");
//        A_Father af = new A_Father();
//        System.out.println("--------");
//        A a = new A();
        System.out.println(A.w);

//        A a2 = new A();
    }
}

class A extends A_Father{
    public static int w = 100;
    public static final int x = 500;
    static {
        System.out.println("静态初始化类A");
        w = 200;
    }

    public A(){
        System.out.println("创建A的对象");
    }
}
class A_Father{
    public static int h = 300;
    static {
        System.out.println("静态初始化类A_Father");
    }
    public A_Father(){
        System.out.println("创建A_Father对象");
    }
}

静态初始化类Demo
开始执行main方法
静态初始化类A_Father
静态初始化类A
200

public class Demo {
    static {
        System.out.println("静态初始化类Demo");
    }
    public static void main(String[] args) {
        System.out.println("开始执行main方法");
//        A_Father af = new A_Father();
//        System.out.println("--------");
//        A a = new A();
        System.out.println(A.x); //调用final常量，不会初始化

//        A a2 = new A();
    }
}

class A extends A_Father{
    public static int w = 100;
    public static final int x = 500;
    static {
        System.out.println("静态初始化类A");
        w = 200;
    }

    public A(){
        System.out.println("创建A的对象");
    }
}

class A_Father{
    public static int h = 300;
    static {
        System.out.println("静态初始化类A_Father");
    }
    public A_Father(){
        System.out.println("创建A_Father对象");
    }
}

静态初始化类Demo
开始执行main方法
500

• 使用java.lang.reflect包中的方法对类进行反射调用；

public class Demo {
    static {
        System.out.println("静态初始化类Demo");
    }
    public static void main(String[] args) throws Exception {
        System.out.println("开始执行main方法");
//        A_Father af = new A_Father();
//        System.out.println("--------");
//        A a = new A();
//        System.out.println(A.x); //调用final常量，不会初始化
        Class.forName("com.zp.InitLearn.A");
//        A a2 = new A();
    }
}

class A extends A_Father{
    public static int w = 100;
    public static final int x = 500;
    static {
        System.out.println("静态初始化类A");
        w = 200;
    }

    public A(){
        System.out.println("创建A的对象");
    }
}

class A_Father{
    public static int h = 300;
    static {
        System.out.println("静态初始化类A_Father");
    }
    public A_Father(){
        System.out.println("创建A_Father对象");
    }
}

• 当虚拟机启动时，java hello。则一定会初始化hello类，就是先启动main方法所在的类；
• 当初始化一个类，如果其父类没有被初始化，则会先初始化其父类。

4. 类的被动引用不会发生类的初始化

• 当访问一个静态域时，只有真正声明这个域的类才会被初始化（通过子类引用父类的静态变量，子类不会被初始化）；
• 通过数组定义类引用，不会触发此类的初始化；
• 引用常量不会触发此类的初始化（常量在编译阶段就存入调用类的常量池中）