JVM之类加载机制总结

在系统介绍类加载机制前，我们先看以下的代码（lz在面试题中经常会见到这种类型的题目），然后我们在这段面试中常出现的的代码里去分析 Java 的类加载机制。

class Grandpa
{
    static
    {
        System.out.println("爷爷在静态代码块");
    }
}    
class Father extends Grandpa
{
    static
    {
        System.out.println("爸爸在静态代码块");
    }

    public static int factor = 55;

    public Father()
    {
        System.out.println("我是爸爸~");
    }
}
class Son extends Father
{
    static 
    {
        System.out.println("儿子在静态代码块");
    }

    public Son()
    {
        System.out.println("我是儿子~");
    }
}
public class InitializationDemo
{
    public static void main(String[] args)
    {
        System.out.println("爸爸的岁数:" + Son.factor);  //入口
    }
}
复制代码

请写出代码最后的输出结果：

正确答案见文章目录： 初探代码

对于刚看到这种类型题目的同学来说，也许是无从下手的，如果不对Java的类加载机制有一定的了解，也许碰见多次这种的题型还是手足无措。

那么接下来就通过学习 Java类加载机制的七个阶段 来学会解决这种类型的题目。

Java类加载机制的七个阶段

• 加载

加载阶段是类加载过程的第一个阶段。在这个阶段，JVM 的主要 目的是:将字节码从各个位置（网络、磁盘等）转化为二进制字节流加载到内存中，接着会为这个类在 JVM 的方法区创建一个对应的 Class 对象，这个 Class对象就是这个类各种数据的访问入口。

注:这个过程对于解决这道题并没有直接的影响，但是对于想要理解类加载机制的完整过程，这个阶段是需要了解的。

• 验证

当 JVM 加载完 Class 字节码文件并在方法区创建对应的 Class 对象之后， JVM 便会启动对该字节码流的校验，这是连接阶段的第一步，这一阶段的目的是为了确保只有符合 JVM 字节码规范的文件才能被 JVM 正确执行。

验证阶段大致上会完成下面4个阶段的检验动作： 文件格式验证、元数据验证、字节码验证、符号引用验证。

• 文件格式验证

这一阶段主要验证字节流是否符合Class文件格式的规范，并且能被当前版本虚拟机所处理。例如：

①主、次版本号是否在当前虚拟机的处理范围之内；

②常量池中的常量是否有不被支持的常量类型（检查常量tag标志）；

...（等）

• 元数据验证

这一阶段是对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言规范的要求。例如：

①这个类的父类是否继承了不允许被继承的类（被final修饰的类）；

②如果这个类不是抽象类，是否实现了其父类或接口之中要求实现的所有方法；

...(等)

• 字节码验证

这一阶段的主要目的是通过对数据流和控制流分析，确保程序语义是合法的，符合逻辑的。例如：

①保证跳转指令不会跳转到方法体以外的字节码指令上；

...（等）

• 符号引用验证

最后一个阶段的校验发生在虚拟机将符号引用转化为直接引用的时候，这个转化动作将在连接的第三阶段，解析阶段发生。符号引用验证可以看做是对类自身以外（常量池中的各种符号引用）的信息进行匹配校验。例如：

①符号引用中通过字符串描述的权限定名是否能找到对应的类；

...（等）

注:这个过程对于解决这道题并没有直接的影响，但是对于想要理解类加载机制的完整过程，这个阶段是需要了解的。

• 准备

当完成字节码文件的校验之后，JVM便会开始为 类变量 分配内存并初始化。这里需要注意两个关键点，即内存分配的对象以及初始化的类型。

内存分配的对象: Java 中的变量有「 类变量 」和「 类成员变量 」两种类型，「 类变量 」指的是被 static 修饰的变量，而其他所有类型的变量都属于「 类成员变量 」。在准备阶段，JVM 只会为「 类变量 」分配内存，而不会为「 类成员变量 」分配内存。「 类成员变量 」的内存分配需要等到初始化阶段才开始。 例如下面的代码在准备阶段，只会为 a 属性分配内存，而不会为 b 属性分配内存。

public static int a = 3;
public String b = "java";
复制代码

初始化的类型。在准备阶段，JVM会为 类变量 分配内存，并为其初始化。 但是这里的初始化指的是为变量赋予 Java 语言中该数据类型的零值，而不是用户代码里初始化的值。 例如下面的代码在准备阶段之后， c 的值将是 0，而不是 3。

public static int c = 3;
复制代码

但如果一个变量是常量（被 static final 修饰）的话，那么在准备阶段，属性便会被赋予用户希望的值。例如下面的代码在准备阶段之后， number 的值将是 3，而不是 0。

public static final int number = 3;
复制代码

之所以 static final 会直接被复制，而 static 变量会被赋予零值。其实我们稍微思考一下就能想明白了。

两个语句的区别是一个有 final 关键字修饰，另外一个没有。而 final 关键字在 Java 中代表不可改变的意思，意思就是说 number 的值一旦赋值就不会在改变了。既然一旦赋值就不会再改变，那么就必须一开始就给其赋予用户想要的值，因此被 final 修饰的类变量在准备阶段就会被赋予想要的值。而没有被 final 修饰的类变量，其可能在初始化阶段或者运行阶段发生变化，所以就没有必要在准备阶段对它赋予用户想要的值。

• 解析

当通过准备阶段之后，JVM针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符 7 类引用进行解析。这个阶段的主要任务是将其在常量池中的符号引用替换成直接其在内存中的直接引用。

注： 同上。

• 初始化

类初始化阶段是类加载过程的最后一步，这个时候用户定义的 Java 程序代码才真正开始执行。

在准备阶段，变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据 程序员 的通过程序指定的主观计划去初始化类变量和其他资源，或者可以从另外一个角度来表达：初始化阶段是执行类构造器 <clinit>() 方法的过程。 <clinit>() 方法执行过程中有以下特点：

① <clinit>() 方法是由编译器自动收集类中的所有类变量的赋值动作和静态语块（ static{} 块） 中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的。例如：

public class Book {
    public static void main(String[] args)
    {
        System.out.println("Hello ShuYi.");
    }

    Book()
    {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +",amount=" + amount);
    }

    {
        System.out.println("书的普通代码块");
    }

    int price = 110;

    static
    {
        System.out.println("书的静态代码块");
    }

    static int amount = 112;
}
复制代码

在这段代码中， <clinit>() 方法就是：

static
    {
        System.out.println("书的静态代码块");
    }
    static int amount = 112;
复制代码

静态语句块只能访问到定义在静态语句块之前的变量，定义在塔之后的变量，在前面的静态语句块可以赋值，但是不能访问。

② 注意 <clinit>() 方法与类的构造函数（或者说实例构造器 <init>() 方法）不同，它不需要显式地调用父类构造器，虚拟机会保证子类的 <clinit>() 方法执行之前，父类的 <clinit>() 方法已经执行完毕。

③由于父类的 <clinit>() 方法先执行，也就意味着父类中定义的静态语句快要优先于子类的变量赋值操作。

④ <clinit>() 方法方法对于类或接口并不是必须的，如果一个类中没有静态语句块，也没有对类变量的赋值操作，那么编译器就可以不为这个类生成 <clinit>() 方法。

• 使用

当 JVM 完成初始化阶段之后，JVM 便开始从入口方法开始执行用户的程序代码。

注： 同上。

• 卸载

当用户程序代码执行完毕后，JVM 便开始销毁创建的 Class 对象，最后负责运行的 JVM 也退出内存。

注： 同上。

初探代码

文章开头那段代码的正确结果为：

爷爷在静态代码块
爸爸在静态代码块
爸爸的岁数:55
复制代码

这里我们观察到，我们在 Son 类中明明定义了以下静态代码块，但并没有输出 儿子在静态代码块

static 
    {
        System.out.println("儿子在静态代码块");
    }
复制代码

这是因为对于静态字段，只有直接定义这个字段的类才会被初始化（执行静态代码块）。就像上面的代码一样， Son 的父类 Father 定义了 factor 即： public static int factor=55; 而子类 Son 并没有定义 factor 的语句，所以，通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

对面上面的这个例子，我们可以从入口开始分析一路分析下去：

• 首先程序到 main 方法这里，使用标准化输出 Son 类中的 factor 类成员变量，但是 Son 类中并没有定义这个类成员变量。于是往父类去找，我们在 Father 类中找到了对应的类成员变量，于是触发了 Father 的初始化。
• 但根据我们上面说到的初始化的 5 种情况中的第 2 种（当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化）。我们需要先初始化 Father 类的父类，也就是先初始化 Grandpa 类再初始化 Father 类。于是我们先初始化 Grandpa 类输出 ：爷爷在静态代码块 ，再初始化 Father 类输出： 爸爸在静态代码块 。
• 最后，所有父类都初始化完成之后， Son 类才能调用父类的静态变量，从而输出： 爸爸的岁数：55 。

而当我们在 Son 类中同样定义 factor ，并赋予不一样的值时，即 public static int factor =66； 那么最终的结果又会变为：

爷爷在静态代码块
爸爸在静态代码块
儿子在静态代码块
爸爸的岁数:66
复制代码

Son 类被初始化，并输出其静态代码块，输出的 factor 值是 Son 类中的定义的值。

再探代码

接下来再看一个升级版的例子：

class Grandpa
{
    static
    {
        System.out.println("爷爷在静态代码块");
    }

    public Grandpa() {
        System.out.println("我是爷爷~");
    }
}
class Father extends Grandpa
{
    static
    {
        System.out.println("爸爸在静态代码块");
    }

    public Father()
    {
        System.out.println("我是爸爸~");
    }
}
class Son extends Father
{
    static 
    {
        System.out.println("儿子在静态代码块");
    }

    public Son()
    {
        System.out.println("我是儿子~");
    }
}
public class InitializationDemo
{
    public static void main(String[] args)
    {
        new Son();  //入口
    }
}
复制代码

输出结果为：

爷爷在静态代码块
爸爸在静态代码块
儿子在静态代码块
我是爷爷~
我是爸爸~
我是儿子~
复制代码

分析执行流程：

• 首先在入口这里我们实例化一个 Son 对象，因此会触发 Son 类的初始化，而 Son 类的初始化又会带动 Father 、 Grandpa 类的初始化，从而执行对应类中的静态代码块。因此会输出：

爷爷在静态代码块
爸爸在静态代码块
儿子在静态代码块
复制代码

当 Son 类完成初始化之后，便会调用 Son 类的构造方法，而 Son 类构造方法的调用同样会带动 Father 、 Grandpa 类构造方法的调用，最后会输出：

我是爷爷~
我是爸爸~
我是儿子~
复制代码

再看一个例子：

public class Book {
    public static void main(String[] args)
    {
        staticFunction();
    }

    static Book book = new Book();

    static
    {
        System.out.println("书的静态代码块");
    }

    {
        System.out.println("书的普通代码块");
    }

    Book()
    {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +",amount=" + amount);
    }

    public static void staticFunction(){
        System.out.println("书的静态方法");
    }

    int price = 110;
    static int amount = 112;
}
复制代码

最终结果：

书的普通代码块
书的构造方法
price=110,amount=0
书的静态代码块
书的静态方法
复制代码

分析：

在上面两个例子中，因为 main 方法所在类并没有多余的代码，我们都直接忽略了 main 方法所在类的初始化。

但在这个例子中， main 方法所在类有许多代码，我们就并不能直接忽略了。

• 当 JVM 在准备阶段的时候，便会为类变量分配内存和进行初始化。此时，我们的 book 实例变量被初始化为 null ， amount 变量被初始化为 0。 当进入初始化阶段后，因为 Book 方法是程序的入口，因为当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类，虚拟机会先初始化这个主类，所以JVM 会初始化 Book 类，即执行类构造器 。
• JVM 对 Book 类进行初始化首先是执行类构造器（按顺序收集类中所有静态代码块和类变量赋值语句就组成了类构造器 后执行对象的构造器（按顺序收集成员变量赋值和普通代码块，最后收集对象构造器，最终组成对象构造器 ）

对于 Book 类，其类构造方法（）可以简单表示如下：

static Book book = new Book();
static
{
    System.out.println("书的静态代码块");
}
static int amount = 112;
复制代码

于是首先执行 static Book book = new Book(); 这一条语句，这条语句又触发了类的实例化。于是 JVM 执行对象构造器 ，收集后的对象构造器 代码：

{
    System.out.println("书的普通代码块");
}
int price = 110;
Book()
{
    System.out.println("书的构造方法");
    System.out.println("price=" + price +", amount=" + amount);
}
复制代码

于是此时 price 赋予 110 的值，输出：

书的普通代码块
书的构造方法
复制代码

而此时 price 为 110 的值，而 amount 的赋值语句并未执行，所以只有在 准备阶段赋予的零值 ，所以之后输出 price=110,amount=0

当类实例化完成之后，JVM 继续进行类构造器的初始化：

static Book book = new Book();  //完成类实例化
static
{
    System.out.println("书的静态代码块");
}
static int amount = 112;
复制代码

即输出： 书的静态代码块 ，之后对 amount 赋予 112 的值。

到这里，类的初始化已经完成，JVM 执行 main 方法的内容。

public static void main(String[] args)
{
    staticFunction();
}
复制代码

即输出： 书的静态方法

总结

从上面几个例子可以看出，分析一个类的执行顺序大概可以按照如下步骤：

• 确定类变量的初始值 。在类加载的准备阶段，JVM会为类变量初始化零值，这时候类变量会有一个初始的零值。如果是被 final 修饰的类变量，则直接会被初始成用户想要的值。
• 初始化入口方法 。当进入类加载的初始化阶段后，JVM 会寻找整个 main 方法入口，从而初始化 main 方法所在的整个类。当需要对一个类进行初始化时，会首先初始化类构造器（），之后初始化对象构造器（）。
• 初始化类构造器 。JVM 会按顺序收集类变量的赋值语句、静态代码块，最终组成类构造器由 JVM 执行。
• 初始化对象构造 器。JVM 会按照收集成员变量的赋值语句、普通代码块，最后收集构造方法，将它们组成对象构造器，最终由 JVM 执行。

如果在初始化 main 方法所在类的时候遇到了其他类的初始化，那么就先加载对应的类，加载完成之后返回。如此反复循环，最终返回 main 方法所在类。