Java 中类加载的时机

Java 中类加载的时机

类加载过程分为加载、链接、初始化三个阶段，从而实现对某个类进行初始化。

在加载阶段，Java 虚拟机通过查找字节流（*.class 文件），并且根据字节流创建 java.lang.Class 对象。在这个过程中，JVM 将类的字节码文件中的二进制数据读入内存，存放在方法区内。然后在堆中创建 java.lang.Class 对象，用来封装类在方法区的数据结构。

类加载阶段：

1. Java 虚拟机将 *.class 文件读入内存，并为之创建一个 Class 对象；
2. 任何类被使用时系统都会为其创建一个且仅有一个 Class 对象；
3. 这个 Class 对象描述了这个类创建出来的对象的所有信息，比如构造方法，成员方法，成员变量，常量池等。

在 Java 虚拟机规范中没有对类加载的时机做强制约束，主要与虚拟机的具体实现有关。但是虚拟机规范严格规定了以下几种情况必须立即对类进行初始化，如果类没有进行过初始化，则需要先触发其初始化。

1. 创建类的实例，即 new 一个对象；
2. 访问类的静态变量；
3. 访问类的静态方法；
4. 反射，通过 Class.forName 加载；
5. 初始化一个类的子类，这会首先初始化子类的父类
6. 虚拟机启动时，会首先加载定义了 main 方法的类

准备

为了验证类加载，需要配置一个 JVM 参数。如果是命令行执行，需要在 java 命令后面加上此参数。如果使用的是 IDE，只需要在设置中配置一下，如下 IDEA。

-XX:+TraceClassLoading

此命令的作用是监控类的加载，可以打印出类的加载信息。

创建类的实例

public class Main {
    public static void main(String[] args) {
        new FirstClass();
    }
}

class FirstClass {
    static {
        System.out.println("FirstClass 静态代码块");
    }
    {
        System.out.println("FirstClass 普通代码块");
    }
    FirstClass() {
        System.out.println("FirstClass 构造函数");
    }
}

首次创建一个类的实例时，可以在类的加载信息找到对应的类名，则可证明该类被加载了。因此使用 new 创建实例对象，会触发类的加载。

访问类的静态变量

public class Main {
    public static void main(String[] args) {
        int a = SecondClass.a;
    }
}
class SecondClass {
    static int a;
    static {
        System.out.println("SecondClass 静态代码块");
    }
    {
        System.out.println("SecondClass 普通代码块");
    }
    SecondClass() {
        System.out.println("SecondClass 构造函数");
    }
}

访问类的静态方法

public class Main {
    public static void main(String[] args) {
        ThirdClass.func();
    }
}
class ThirdClass {
    static void func() {
        System.out.println("ThirdClass 静态方法");
    }
    static {
        System.out.println("ThirdClass 静态代码块");
    }
    {
        System.out.println("ThirdClass 普通代码块");
    }
    ThirdClass() {
        System.out.println("ThirdClass 构造函数");
    }
}

反射

public class Main {
    public static void main(String[] args) {
        try {
            Class.forName("FourthClass");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            ClassLoader.getSystemClassLoader().loadClass("FourthClass");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
class FourthClass {
    static {
        System.out.println("FourthClass 静态代码块");
    }
    {
        System.out.println("FourthClass 普通代码块");
    }
    FourthClass() {
        System.out.println("FourthClass 构造函数");
    }
}

初始化子类

public class Main {
    public static void main(String[] args) {
        new SubClass();
        int a = SubClass.a;
        SubClass.func();
        try {
            Class.forName("demo.SubClass");  // 反射
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
class SuperClass {
    static {
        System.out.println("SuperClass 静态代码块");
    }
    {
        System.out.println("SuperClass 普通代码块");
    }
    SuperClass() {
        System.out.println("SuperClass 构造函数");
    }
}
class SubClass extends SuperClass {
    static int a;
    static void func() {
        System.out.println("SubClass 静态方法");
    }
    static {
        System.out.println("SubClass 静态代码块");
    }
    {
        System.out.println("SubClass 普通代码块");
    }
    SubClass() {
        System.out.println("SubClass 构造函数");
    }
}

虚拟机启动

public class Main {
    static {
        System.out.println("Main 静态代码块");
    }
    {
        System.out.println("Main 普通代码块");
    }
    Main() {
        System.out.println("Main 构造函数");
    }
    public static void main(String[] args) {
        // System.out.println("main 方法");
    }
}