别再说你会 new Object() 了！JVM 类加载的真相，绝对和你想的不一样

当我们编写 new Object() 时，JVM 背后到底发生了怎样的故事？类加载过程中的初始化阶段究竟暗藏哪些玄机？

一、引言：从一段简单代码说起

先来看一个看似简单的 Java 代码片段：

public class HelloWorld {
public static void main(String[] args) {

        System.out.println("Hello, World!");

    }

}

当我们执行这段代码时，背后却隐藏着 JVM 复杂的类加载机制。.java 文件经过编译变成 .class 字节码文件，这些"静态"的字节码需要被 JVM 动态地加载、处理并最终执行。这就是类加载过程的神奇之处。

类加载机制是 Java 语言的核心基石，它赋予了 Java "一次编写，到处运行" 的能力。理解这一过程，不仅能帮助我们编写更高效的代码，更是面试中的高频考点。

二、类生命周期：七个阶段的完整旅程

在深入类加载过程之前，我们先来了解类的完整生命周期。一个类在 JVM 中从加载到卸载，总共经历七个阶段：

阶段	描述	是否必须	特点	JVM规范要求
加载(Loading)	查找并加载类的二进制数据	是	将字节码读入内存，生成Class对象	强制
验证(Verification)	确保被加载的类正确无误	是	安全验证，防止恶意代码	强制
准备(Preparation)	为类变量分配内存并设置初始零值	是	注意：不是程序员定义的初始值	强制
解析(Resolution)	将符号引用转换为直接引用	否	可以在初始化后再进行	可选
初始化(Initialization)	执行类构造器 `<clinit>()` 方法	是	初始化类而不是对象	强制
使用(Using)	正常使用类的功能	是	类的使命阶段	-
卸载(Unloading)	从内存中释放类数据	否	由垃圾回收器负责	可选

前五个阶段（加载、验证、准备、解析、初始化）统称为类加载过程。

三、类加载过程的五个步骤详解

3.1 加载阶段：寻找类的旅程

加载阶段是类加载过程的起点，主要完成三件事情：

通过类的全限定名获取定义此类的二进制字节流
将这个字节流所代表的静态存储结构转换为方法区的运行时数据结构
在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区这个类的各种数据的访问入口

// 示例：不同的类加载方式
public class LoadingExample {
public static void main(String[] args) throws Exception {
// 通过类加载器加载

        Class<?> clazz1 = ClassLoader.getSystemClassLoader().loadClass("java.lang.String");

// 通过Class.forName加载（默认会初始化）

        Class<?> clazz2 = Class.forName("java.lang.String");

// 通过字面常量获取（不会触发初始化）

        Class<?> clazz3 = String.class;


        System.out.println("三种方式加载的类是否相同: " + 

                          (clazz1 == clazz2 && clazz2 == clazz3));

    }

}

3.2 验证阶段：安全的第一道防线

验证阶段确保 Class 文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求，保证这些信息不会危害虚拟机自身的安全。

验证类型	验证内容	失败后果
文件格式验证	魔数（0xCAFEBABE）、版本号、常量池	ClassFormatError
元数据验证	语义验证、继承关系（如是否实现抽象方法）	IncompatibleClassChangeError
字节码验证	逻辑验证、跳转指令合法性	VerifyError
符号引用验证	引用真实性、访问权限（如访问private方法）	NoSuchFieldError、NoSuchMethodError

3.3 准备阶段：零值初始化的奥秘

这是最容易产生误解的阶段！ 在准备阶段，JVM 为**类变量（static变量）**分配内存并设置初始零值，注意这不是程序员定义的初始值。

public class PreparationExample {
// 准备阶段后 value = 0，而不是 100
public static int value = 100;

// 准备阶段后 constantValue = 200（因为有final修饰）
public static final int constantValue = 200;

// 实例变量 - 准备阶段完全不管
public int instanceValue = 300;

}

各种数据类型的零值对照表：

数据类型	零值	数据类型	零值
int	0	boolean	false
long	0L	float	0.0f
double	0.0	char	'\u0000'
引用类型	null	short	(short)0

关键区别：只有**类变量（static变量）**在准备阶段分配内存和初始化零值，实例变量会在对象实例化时随对象一起分配在堆内存中。

3.4 解析阶段：符号引用到直接引用的转换

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。这个过程可以在初始化之后再进行，这是为了支持Java的动态绑定特性。

解析主要针对以下四类符号引用：

引用类型	解析目标	可能抛出的异常
类/接口解析	将符号引用解析为具体类/接口	NoClassDefFoundError
字段解析	解析字段所属的类/接口	NoSuchFieldError
方法解析	解析方法所属的类/接口	NoSuchMethodError
接口方法解析	解析接口方法所属的接口	AbstractMethodError

3.5 初始化阶段：执行类构造器 `<clinit>()`

这是类加载过程的最后一步，也是真正开始执行类中定义的Java程序代码的一步。

JVM规范严格规定的六种初始化触发情况：

遇到new、getstatic、putstatic或invokestatic这四条字节码指令时

// new指令 - 创建类的实例
Object obj = new Object();

// getstatic指令 - 读取类的静态字段
int value = MyClass.staticField;

// putstatic指令 - 设置类的静态字段  

MyClass.staticField = 100;

// invokestatic指令 - 调用类的静态方法

MyClass.staticMethod();

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

// 反射调用会触发类的初始化

Class<?> clazz = Class.forName("com.example.MyClass");

当初始化一个类时，发现其父类还没有进行过初始化

class Parent {
static { System.out.println("Parent初始化"); }

}

class Child extends Parent {
static { System.out.println("Child初始化"); }

}
// 初始化Child时会先初始化Parent

虚拟机启动时，用户指定的主类（包含main()方法的那个类）

// 执行 java MyApp 时，MyApp类会被初始化
public class MyApp {
public static void main(String[] args) {

        System.out.println("应用程序启动");

    }

}

使用JDK7新加入的动态语言支持时

// 使用MethodHandle等动态语言特性

MethodHandles.Lookup lookup = MethodHandles.lookup();

一个接口中定义了JDK8新加入的默认方法时，如果这个接口的实现类发生了初始化，要先将接口进行初始化

interface MyInterface {
// JDK8默认方法会触发接口初始化
default void defaultMethod() {

        System.out.println("默认方法");

    }

}

3.6 使用阶段：类的使命实现

当类完成初始化后，就进入了使用阶段。这是类生命周期中最长的阶段，类的所有功能都可以正常使用：

public class UsageStageExample {
public static void main(String[] args) {
// 类已完成初始化，进入使用阶段
MyClass obj = new MyClass();  // 创建对象实例

        obj.instanceMethod();         // 调用实例方法

        MyClass.staticMethod();       // 调用静态方法
int value = MyClass.staticVar;// 访问静态变量

    }

}

class MyClass {
public static int staticVar = 100;
public int instanceVar = 200;

public static void staticMethod() {

        System.out.println("静态方法");

    }

public void instanceMethod() {

        System.out.println("实例方法");

    }

}

在使用阶段，类可以：

创建对象实例
调用静态方法和实例方法
访问和修改静态字段和实例字段
被其他类引用和继承

3.7 卸载阶段：生命的终结

类的卸载是生命周期的最后阶段，但并不是必须发生的。一个类被卸载需要满足以下条件：

该类所有的实例都已被垃圾回收
加载该类的ClassLoader已被垃圾回收
该类对应的java.lang.Class对象没有被任何地方引用

public class UnloadingExample {
public static void main(String[] args) throws Exception {
// 使用自定义类加载器加载类
CustomClassLoader loader = new CustomClassLoader();

        Class<?> clazz = loader.loadClass("com.example.TemporaryClass");

// 创建实例并使用
Object instance = clazz.newInstance();

        System.out.println("类已加载并使用: " + clazz.getName());

// 解除所有引用，使类和类加载器可被回收

        clazz = null;

        instance = null;

        loader = null;

// 触发GC，可能卸载类

        System.gc();

        System.out.println("类和类加载器可能已被卸载");

    }

}

class CustomClassLoader extends ClassLoader {
// 自定义类加载器实现

}

所以，在 JVM 生命周期内，由 jvm 自带的类加载器加载的类是不会被卸载的。但是由我们自定义的类加载器加载的类是可能被卸载的。

四、关键辨析：类初始化 vs. 对象实例化

这是本文的核心观点，也是大多数开发者容易混淆的概念。让我们通过一个对比表格来清晰区分：

特性	类初始化 (Initialization)	对象实例化 (Instantiation)
触发时机	类被首次"主动使用"时（JVM控制）	遇到new关键字时（程序员控制）
发生次数	一次（每个类加载器范围内）	多次（可以创建多个对象实例）
核心方法	`<clinit>()`方法	`<init>()`方法（构造函数）
操作目标	类本身（初始化静态变量/类变量）	对象实例（初始化实例变量）
内存区域	方法区（元空间）	Java堆
执行内容	静态变量赋值、静态代码块	实例变量赋值、实例代码块、构造函数

public class InitializationVsInstantiation {
// 类变量 - 在<clinit>()方法中初始化
public static String staticField = initStaticField();

// 实例变量 - 在<init>()方法中初始化  
public String instanceField = initInstanceField();

// 静态代码块 - 在<clinit>()方法中执行
static {

        System.out.println("静态代码块执行");

    }

// 实例代码块 - 在<init>()方法中执行

    {

        System.out.println("实例代码块执行");

    }

public InitializationVsInstantiation() {

        System.out.println("构造方法执行");

    }

private static String initStaticField() {

        System.out.println("静态变量初始化");
return "static value";

    }

private String initInstanceField() {

        System.out.println("实例变量初始化");
return "instance value";

    }

public static void main(String[] args) {

        System.out.println("=== 第一次创建对象 ===");
new InitializationVsInstantiation();


        System.out.println("\n=== 第二次创建对象 ===");
new InitializationVsInstantiation();

    }

}

输出结果：

静态变量初始化

静态代码块执行
=== 第一次创建对象 ===

实例变量初始化

实例代码块执行

构造方法执行

=== 第二次创建对象 ===

实例变量初始化

实例代码块执行

构造方法执行

五、深度实战：初始化顺序全面解析

现在，让我们通过一个综合示例来回答开篇的思考题：如果一个类同时包含静态变量、静态代码块、实例变量、实例代码块和构造方法，它们的执行顺序是怎样的？在存在继承关系时又会如何变化？

5.1 单类初始化顺序

public class InitializationOrder {
// 静态变量
public static String staticField = "静态变量";

// 静态代码块
static {

        System.out.println(staticField);

        System.out.println("静态代码块");

    }

// 实例变量
public String field = "实例变量";

// 实例代码块

    {

        System.out.println(field);

        System.out.println("实例代码块");

    }

// 构造方法
public InitializationOrder() {

        System.out.println("构造方法");

    }

public static void main(String[] args) {

        System.out.println("第一次实例化:");
new InitializationOrder();


        System.out.println("\n第二次实例化:");
new InitializationOrder();

    }

}

输出结果：

静态变量

静态代码块
第一次实例化:

实例变量

实例代码块

构造方法

第二次实例化:

实例变量

实例代码块

构造方法

关键发现：

静态代码块只在类第一次加载时执行一次
实例代码块在每次创建对象时都会执行
执行顺序：静态变量/代码块 → 实例变量/代码块 → 构造方法

5.2 继承关系下的初始化顺序

class Parent {
// 父类静态变量
public static String parentStaticField = "父类静态变量";

// 父类静态代码块
static {

        System.out.println(parentStaticField);

        System.out.println("父类静态代码块");

    }

// 父类实例变量
public String parentField = "父类实例变量";

// 父类实例代码块

    {

        System.out.println(parentField);

        System.out.println("父类实例代码块");

    }

// 父类构造方法
public Parent() {

        System.out.println("父类构造方法");

    }

}

class Child extends Parent {
// 子类静态变量
public static String childStaticField = "子类静态变量";

// 子类静态代码块
static {

        System.out.println(childStaticField);

        System.out.println("子类静态代码块");

    }

// 子类实例变量
public String childField = "子类实例变量";

// 子类实例代码块

    {

        System.out.println(childField);

        System.out.println("子类实例代码块");

    }

// 子类构造方法
public Child() {

        System.out.println("子类构造方法");

    }

public static void main(String[] args) {

        System.out.println("第一次实例化子类:");
new Child();


        System.out.println("\n第二次实例化子类:");
new Child();

    }

}

输出结果：

父类静态变量

父类静态代码块

子类静态变量

子类静态代码块
第一次实例化子类:

父类实例变量

父类实例代码块

父类构造方法

子类实例变量

子类实例代码块

子类构造方法

第二次实例化子类:

父类实例变量

父类实例代码块

父类构造方法

子类实例变量

子类实例代码块

子类构造方法

关键发现：

父类静态代码块 → 子类静态代码块 → 父类实例代码块 → 父类构造方法 → 子类实例代码块 → 子类构造方法
静态代码块只执行一次，实例代码块每次创建对象都执行
父类优先于子类初始化

5.3 进阶案例：包含静态变量初始化的复杂情况

public class ComplexInitialization {
public static ComplexInitialization instance = new ComplexInitialization();
public static int staticVar = 100;
public int instanceVar = 200;

static {

        System.out.println("静态代码块: staticVar=" + staticVar);

    }


    {

        System.out.println("实例代码块: instanceVar=" + instanceVar + ", staticVar=" + staticVar);

    }

public ComplexInitialization() {

        System.out.println("构造方法: instanceVar=" + instanceVar + ", staticVar=" + staticVar);

    }

public static void main(String[] args) {

        System.out.println("main方法开始");
new ComplexInitialization();

    }

}

输出结果：

实例代码块: instanceVar=200, staticVar=0

构造方法: instanceVar=200, staticVar=0

静态代码块: staticVar=100

main方法开始

实例代码块: instanceVar=200, staticVar=100

构造方法: instanceVar=200, staticVar=100

关键发现：

静态变量 staticVar 在准备阶段被初始化为0
在初始化阶段，按顺序执行静态变量赋值和静态代码块
当执行 instance = new ComplexInitialization() 时，staticVar 还未被赋值为100（还是0）
这解释了为什么第一次输出时 staticVar=0

六、面试常见问题与解答

6.1 高频面试题解析

Q1: 下面代码的输出结果是什么？为什么？

public class InterviewQuestion {
public static void main(String[] args) {

        System.out.println(Child.value);

    }

}

class Parent {
static int value = 100;
static { System.out.println("Parent静态代码块"); }

}

class Child extends Parent {
static { System.out.println("Child静态代码块"); }

}

A: 输出结果为：

Parent静态代码块

100

解析： 通过子类引用父类的静态字段，不会导致子类初始化，这是类加载机制的一个重要特性。

Q2: 接口的初始化与类有什么不同？

A: 接口的初始化与类类似，但有重要区别：

接口也有 <clinit>() 方法，由编译器自动生成
接口初始化时不需要先初始化父接口
只有当程序首次使用接口中定义的非常量字段时，才会初始化接口

6.2 类加载机制的实际应用

1. 单例模式的优雅实现：

public class Singleton {
private Singleton() {}

private static class SingletonHolder {
static {

            System.out.println("SingletonHolder初始化");

        }
private static final Singleton INSTANCE = new Singleton();

    }

public static Singleton getInstance() {
return SingletonHolder.INSTANCE;

    }

}

这种实现利用了类加载机制的特性：只有在真正调用 getInstance() 时才会加载 SingletonHolder 类，实现了懒加载且线程安全。

2. 常量传播优化：

public class ConstantExample {
public static final String CONSTANT = "Hello";

public static void main(String[] args) {

        System.out.println(CONSTANT);

    }

}

编译时，常量 CONSTANT 的值会被直接内联到使用处，不会触发类的初始化。

七、总结与思考

通过本文的深入分析，我们可以总结出以下几个关键点：

类加载过程五个阶段：加载 → 验证 → 准备 → 解析 → 初始化，每个阶段都有其特定任务
关键区别：
- 初始化阶段是初始化类(执行<clinit>())，而不是初始化对象（执行<init>()）
- 类静态变量在准备阶段分配内存并设置零值，在初始化阶段赋实际值
- 实例变量在对象实例化时分配内存和初始化
初始化顺序原则：
- 父类优先于子类
- 静态优先于实例
- 变量定义顺序决定初始化顺序
实际应用：理解类加载机制有助于我们编写更高效的代码，如实现懒加载的单例模式、理解常量内联优化等

希望本文能帮助你深入理解JVM类加载机制，下次遇到相关面试题时，相信你一定能游刃有余！

一、引言：从一段简单代码说起

二、类生命周期：七个阶段的完整旅程

三、类加载过程的五个步骤详解

3.1 加载阶段：寻找类的旅程

3.2 验证阶段：安全的第一道防线

3.3 准备阶段：零值初始化的奥秘

3.4 解析阶段：符号引用到直接引用的转换

3.5 初始化阶段：执行类构造器 `<clinit>()`

JVM规范严格规定的六种初始化触发情况：

3.6 使用阶段：类的使命实现

3.7 卸载阶段：生命的终结

四、关键辨析：类初始化 vs. 对象实例化

五、深度实战：初始化顺序全面解析

5.1 单类初始化顺序

5.2 继承关系下的初始化顺序

5.3 进阶案例：包含静态变量初始化的复杂情况

六、面试常见问题与解答

6.1 高频面试题解析

6.2 类加载机制的实际应用

七、总结与思考

0 个评论

发起人

推荐内容

别再说你会 new Object() 了！JVM 类加载的真相，绝对和你想的不一样

一、引言：从一段简单代码说起

二、类生命周期：七个阶段的完整旅程

三、类加载过程的五个步骤详解

3.1 加载阶段：寻找类的旅程

3.2 验证阶段：安全的第一道防线

3.3 准备阶段：零值初始化的奥秘

3.4 解析阶段：符号引用到直接引用的转换

3.5 初始化阶段：执行类构造器 <clinit>()

JVM规范严格规定的六种初始化触发情况：

3.6 使用阶段：类的使命实现

3.7 卸载阶段：生命的终结

四、关键辨析：类初始化 vs. 对象实例化

五、深度实战：初始化顺序全面解析

5.1 单类初始化顺序

5.2 继承关系下的初始化顺序

5.3 进阶案例：包含静态变量初始化的复杂情况

六、面试常见问题与解答

6.1 高频面试题解析

6.2 类加载机制的实际应用

七、总结与思考

0 个评论

发起人

推荐内容

3.5 初始化阶段：执行类构造器 `<clinit>()`