理解 Java 对象的创建过程：从类加载到实例初始化 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

解剖Java对象的诞生：一场从无到有的奇妙旅程

各位看官，大家好！今天咱们不聊家长里短，咱们聊聊Java世界里最基础、最核心，也是最让人着迷的玩意儿——对象。啥是对象？简单来说，对象就是程序里的一个实体，它有自己的属性（数据）和行为（方法）。但是，你有没有想过，这些对象是怎么凭空出现的？就像孙悟空从石头里蹦出来一样，Java对象也经历了一场精彩的“诞生记”。

今天，咱们就来一起扒一扒Java对象的创建过程，从类加载到实例初始化，保证让你看得明白，学得扎实，以后面试再也不怕被问到这个“送命题”了！

第一幕：类加载——对象的蓝图就位

在Java的世界里，万物皆对象。但是，对象不是凭空产生的，它需要一个“蓝图”，这个蓝图就是类（Class）。类定义了对象的属性和行为，就像房子的设计图一样，决定了房子长什么样，有什么功能。

那么，类是怎么被加载到JVM（Java虚拟机）里的呢？这就涉及到类加载机制了。类加载器就像一个勤劳的搬运工，负责把类的字节码文件（.class文件）加载到JVM中，并进行各种处理，最终形成可以被JVM使用的Class对象。

类加载的过程可以分为三个主要的阶段：

加载（Loading）：
- 这个阶段，类加载器会根据类的全限定名（例如：com.example.MyClass）找到对应的.class文件。
- 然后，它会读取.class文件中的字节码信息。
- 接着，它会在内存中创建一个代表这个类的Class对象。这个Class对象是访问类中各种数据的入口。
- 需要注意的是，加载阶段仅仅是创建了Class对象，并没有进行任何的链接操作。
```
// 假设我们有一个类 MyClass
package com.example;

public class MyClass {
    private int value;

    public MyClass(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}
```
当JVM需要使用MyClass时，类加载器会找到 com/example/MyClass.class 文件，读取其字节码，并在内存中创建一个 java.lang.Class 的实例来代表这个类。
链接（Linking）：

链接阶段负责将加载到的二进制数据合并到JVM的运行时状态中。这个阶段又可以分为三个子阶段：
- 验证（Verification）： 验证阶段确保.class文件的字节码符合JVM规范，不会危害JVM的安全。它会检查文件格式、字节码指令的合法性等等。如果验证失败，JVM会抛出VerifyError。
- 准备（Preparation）： 准备阶段为类的静态变量分配内存，并设置默认初始值。注意，这里是默认初始值，例如int类型的静态变量会被初始化为0，boolean类型的静态变量会被初始化为false，引用类型的静态变量会被初始化为null。
- 解析（Resolution）： 解析阶段将符号引用替换为直接引用。符号引用是指用符号来描述目标，例如方法名、字段名等等。直接引用是指指向目标的指针、偏移量等等。
举个例子：
```
public class StaticExample {
    public static int count = 10; // 准备阶段：count分配内存，默认值为0；初始化阶段：count赋值为10
}
```
在准备阶段，count会被分配内存，并初始化为0。

初始化（Initialization）：

初始化阶段是类加载的最后一步，也是最重要的一步。在这个阶段，JVM会执行类的静态初始化器（static initializer）和静态变量的赋值操作。静态初始化器是一个用static {} 包裹的代码块，它会在类加载时执行一次。

public class StaticExample {
    public static int count;

    static {
        count = 10; // 在初始化阶段，count被赋值为10
        System.out.println("StaticExample 类被初始化了！");
    }

    public StaticExample() {
        System.out.println("StaticExample 对象被创建了！");
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("开始执行...");
        System.out.println("Count 的值：" + StaticExample.count); // 触发 StaticExample 类的初始化
        StaticExample example = new StaticExample(); // 创建 StaticExample 对象
    }
}

输出结果：

开始执行...
StaticExample 类被初始化了！
Count 的值：10
StaticExample 对象被创建了！

可以看到，在访问 StaticExample.count 之前，StaticExample 类已经被初始化了。

类加载器的种类

Java提供了多种类加载器，每种类加载器负责加载不同来源的类。常见的类加载器有：

启动类加载器（Bootstrap ClassLoader）： 负责加载JAVA_HOME/lib目录下的核心类库，例如java.lang.*等。它是用C++实现的，不是Java类。
扩展类加载器（Extension ClassLoader）： 负责加载JAVA_HOME/lib/ext目录下的扩展类库。
应用程序类加载器（Application ClassLoader）： 负责加载用户类路径（CLASSPATH）下的类库，也就是我们自己编写的类。
自定义类加载器（User-Defined ClassLoader）： 我们可以自定义类加载器，加载特定位置的类，或者对类进行一些特殊处理。

双亲委派机制

Java采用双亲委派机制来加载类。当一个类加载器收到类加载请求时，它不会自己去加载，而是将请求委派给父类加载器，直到顶层的启动类加载器。只有当父类加载器无法加载时，子类加载器才会尝试自己加载。

这种机制保证了Java核心类库的安全性，避免了用户自定义的类覆盖核心类库中的类。

第二幕：内存分配——对象的安身之所

当类加载完成后，我们就有了创建对象的“蓝图”。接下来，JVM需要为对象分配内存，也就是给对象找一个“房子”。

JVM的内存区域主要分为以下几个部分：

堆（Heap）： 堆是JVM中最大的一块内存区域，所有对象实例都存储在这里。堆是所有线程共享的。
方法区（Method Area）： 方法区用于存储类的信息、常量、静态变量等。方法区也是所有线程共享的。
虚拟机栈（VM Stack）： 每个线程都有自己的虚拟机栈，用于存储方法调用的局部变量、操作数栈、动态链接等信息。
本地方法栈（Native Method Stack）： 与虚拟机栈类似，但是用于执行本地方法（Native Method）。
程序计数器（Program Counter Register）： 每个线程都有自己的程序计数器，用于记录当前线程执行的字节码指令的地址。

对象实例存储在堆中。当我们需要创建一个对象时，JVM会在堆中找到一块足够大的空闲内存，分配给这个对象。

内存分配的方式

JVM分配内存的方式有两种：

指针碰撞（Bump the Pointer）： 如果堆中的内存是规整的，也就是所有已使用的内存都在一边，所有空闲的内存都在另一边，那么JVM只需要移动一个指针，指向下一个空闲的内存地址即可。
空闲列表（Free List）： 如果堆中的内存不是规整的，也就是已使用的内存和空闲的内存交错在一起，那么JVM需要维护一个空闲列表，记录所有空闲的内存块的地址。当需要分配内存时，JVM会从空闲列表中找到一块足够大的空闲内存，分配给对象。

选择哪种内存分配方式取决于堆的内存是否规整。而堆的内存是否规整，又取决于垃圾回收器是否使用了带有压缩功能的算法。

第三幕：实例初始化——赋予对象生命

分配完内存后，JVM还需要对对象进行初始化，也就是给对象的属性赋值，让对象真正“活”起来。

实例初始化的过程可以分为以下几个步骤：

默认初始化： JVM会将对象的属性设置为默认初始值。例如，int类型的属性会被初始化为0，boolean类型的属性会被初始化为false，引用类型的属性会被初始化为null。

public class Person {
    private String name;
    private int age;

    public Person() {
        // 在这里，name 默认为 null，age 默认为 0
        System.out.println("默认初始化后：name = " + name + ", age = " + age);
    }
}

// 创建 Person 对象
Person person = new Person();

输出：

默认初始化后：name = null, age = 0

显式初始化： 如果在声明属性时，给属性赋了初始值，那么JVM会将属性设置为这个初始值。

public class Person {
    private String name = "Unknown";
    private int age = 18;

    public Person() {
        // 在这里，name 为 "Unknown"，age 为 18
        System.out.println("显式初始化后：name = " + name + ", age = " + age);
    }
}

// 创建 Person 对象
Person person = new Person();

输出：

显式初始化后：name = Unknown, age = 18

构造器初始化： 构造器是用来创建对象的特殊方法。在构造器中，我们可以对对象的属性进行更复杂的初始化操作。

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造器初始化后：name = " + name + ", age = " + age);
    }
}

// 创建 Person 对象
Person person = new Person("Alice", 25);

输出：

构造器初始化后：name = Alice, age = 25

初始化顺序

对象的初始化顺序是固定的：

父类的静态成员变量和静态初始化块，按定义顺序执行。
子类的静态成员变量和静态初始化块，按定义顺序执行。
父类的实例成员变量，按定义顺序执行。
父类的构造器。
子类的实例成员变量，按定义顺序执行。
子类的构造器。

这个顺序很重要，理解了这个顺序，才能避免一些意想不到的错误。

一个更复杂的例子

class Parent {
    public static int parentStaticField = 1;
    public int parentField = 2;

    static {
        System.out.println("Parent static block, parentStaticField = " + parentStaticField);
        parentStaticField = 3;
    }

    {
        System.out.println("Parent instance block, parentField = " + parentField);
        parentField = 4;
    }

    public Parent() {
        System.out.println("Parent constructor, parentField = " + parentField);
    }
}

class Child extends Parent {
    public static int childStaticField = 5;
    public int childField = 6;

    static {
        System.out.println("Child static block, childStaticField = " + childStaticField);
        childStaticField = 7;
    }

    {
        System.out.println("Child instance block, childField = " + childField);
        childField = 8;
    }

    public Child() {
        System.out.println("Child constructor, childField = " + childField);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Creating Child object...");
        Child child = new Child();
    }
}

输出结果：

Creating Child object...
Parent static block, parentStaticField = 1
Child static block, childStaticField = 5
Parent instance block, parentField = 2
Parent constructor, parentField = 4
Child instance block, childField = 6
Child constructor, childField = 8

总结

Java对象的创建过程，就像一场精心编排的舞台剧，从类加载到内存分配，再到实例初始化，每一个环节都至关重要。理解了这个过程，你才能更好地理解Java的运行机制，写出更高效、更健壮的代码。

阶段	描述	关键步骤
类加载	将类的字节码文件加载到JVM中，并创建Class对象。	加载：读取.class文件，创建Class对象。链接：验证字节码，分配静态变量内存，解析符号引用。初始化：执行静态初始化器和静态变量赋值。
内存分配	在堆中为对象分配内存空间。	指针碰撞或空闲列表。
实例初始化	对对象的属性进行初始化，赋予对象生命。	默认初始化：设置属性的默认值。显式初始化：设置属性的初始值。构造器初始化：通过构造器设置属性的值。

希望这篇文章能够帮助你更好地理解Java对象的创建过程。如果你觉得有用，不妨点个赞，分享给你的朋友们。咱们下期再见！

解剖Java对象的诞生：一场从无到有的奇妙旅程

发表回复 取消回复

发表回复取消回复