要研究类加载过程，我们先要知道关于 Java 处理代码的流程是怎么样的。

第一步：编写源代码

这一步是我们最熟悉的，就是我们在 idea 上写的业务代码，生成 Example.java 文件。

public class Example {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int sum = a + b;
        System.out.println(sum);
    }
}

第二步：编译源代码

我们通过 java 编译器（如‘javac’）将我们编写的源代码编译成字节码。

wtf is 字节码？

要知道字节码之前，要先知道机器码。

wtf is 机器码？

机器码就是机器才能看懂的码，机器能看懂什么码？机器就只能看懂‘0100110’这种二进制码。

这种码有这样几个特点：特定于硬件、高效、难以理解。

C、C++的源代码通过编译器就可以转换成机器码，你写成什么样，机器就执行成什么样。

我们再说回字节码。

字节码不同于机器码，它是一种中间代码，它不直接跟机器对话，它是面向 Java 虚拟机的（java 虚拟机与机器对话），而不是任何硬件，这也是字节码区别于机器码的主要特征。
也是所谓“一次编写，到处运行”的特征的主要大功臣。

我们把 Example.java 编译成字节码，存储在 Example.class 中。

它长这样：

cafe babe 0000 0034 005e 0a00 1500 4709
0005 0048 0900 0500 4909 0005 004a 0700
4b0a 0005 004c 0a00 0500 4d0a 0015 004e

这是给人看的？当然不是，这个给虚拟机看的。

JDK 提供自带的反编译工具，执行 **javap -v Example.class **可以将看不懂的上述字节码反编译成给人看的字节码，它长这样：

Compiled from "Example.java"
public class Example {
  public Example();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: bipush        10
       2: istore_1
       3: bipush        20
       5: istore_2
       6: iload_1
       7: iload_2
       8: iadd
       9: istore_3
      10: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      13: iload_3
      14: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
      17: return
}

什么？这你也看不懂？你不学肯定看不懂啊。

不过不懂没关系，这不是我们的任务，我们暂时或者永远也不需要看懂。

我们只要知道 Java 虚拟机大概在做什么就好了。

编译完了以后进行下一步。

第三步：加载字节码

有了 JVM 能看懂的字节码，你得用起来吧，所以 JVM 就得去读取字节码、创建相应的类等。

这就到了我们这一篇文章所要研究的东西了，类加载。

这一步需要特别注意，这里所谓的“类”，指的是class 文件，而这个 class 文件也不是单纯指的是编译后产生的.class 文件，而是一串二进制字节流，它可能来源于磁盘文件、网络、数据库、内存或者动态产生。所以理解的时候不要过于片面。

接下来进入主题！

JVM 类加载机制

定义

Java 虚拟机把描述类的数据从 Class 文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的 Java 类型，这个过程被称作虚拟机的类加载机制。

类加载的时机

在讲类加载时机之前我们需要先讲类的生命周期：

加载、验证、准备、解析、初始化、使用、卸载。

这是 7 个阶段，我们有以下 3 点要知道：

验证、准备、解析阶段统称为链接阶段（Linking）
类加载包含三步：加载、链接、初始化，也就是说本篇不讨论使用和卸载这 2 个阶段
解析阶段可能在初始化前，也可能在初始化后，后面会解释。

具体 7 个阶段在做什么，我们后面会逐一解释。

下面我们讨论本小节重点：类加载的时机。

我们记住以下 2 个事实：

类加载包含 3 步：加载、链接、初始化（上面提到过）
加载、验证、准备、初始化、卸载这 5 步必须按部就班，不准乱序

那么这个类加载到底什么时候发生呢？

JVM 规范对“加载”（loading,即类加载第一小步）这个阶段没有约束，也就是说，我们无法根据“什么时候 loading”来判断“什么时候类加载开始了”。

那 JVM 约束了什么呢？

JVM 规定了有 6 种情况必须立即对类进行初始化，我们前边说了：

初始化是类加载的其中一步
加载验证一定发生在初始化之前

我们我们就笼统的下一个结论：

JVM 规定的这 6 种情况，只要发生了，就说明了类加载过程一定发生了。
JVM 规定的这 6 种情况，只要发生了，就说明了类加载过程一定发生了。
JVM 规定的这 6 种情况，只要发生了，就说明了类加载过程一定发生了。

那么哪 6 种情况呢？

这 6 种情况可以统一成一种情况：对一个类进行主动引用时。

那么有主动引用就会有被动引用咯。

再换句话说：

对一个类进行主动引用时，就会触发初始化，即触发类加载过程。
对一个类进行被动引用时，就不会触发初始化，也就不会触发类加载过程。

下面我们分别讲主动引用的 6 种情况和被动引用的 3 个例子。

主动引用的 6 种情况

使用 new 关键字实例化对象时
读取或设置类的静态字段时（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）
调用类的静态方法时
对类进行反射调用时

什么？你不会反射？《Java反射，看完就会用》

当初始化类时，发现父类没有初始化时，要先初始化其父类
虚拟机启动时，初始化包含 main()方法的那个主类

其实《深入理解 Java 虚拟机》中还有 2 种：

使用 JDK 7 新加入的动态语言支持时
接口中定义了 default 默认方法，此接口的实现类初始化时要先初始化此接口

以上前 6 种基本都比较好理解，就不啰嗦了，第 7 种我自己根本看不懂，也不想研究，有想研究的自己研究一下吧，在第七章 7.2 小节中。

被动引用的 3 个例子

通过子类引用父类的静态字段，不会导致子类初始化

public class Father {
    static {
        System.out.println("父类初始化完成！");
    }

    public static int value = 123;
}

public class Son extends Father {
    static {
        System.out.println("子类初始化完成！");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Son.value);
    }
}

输出结果：

父类初始化完成！
123

通过数组定义来引用类，不会导致此类的初始化

依然使用上面的 Father、Son 类，测试如下：

public class Test02 {
    public static void main(String[] args) {
        Father[] arr = new Father[10];
    }
}

运行结果没有任何输出，说明没有触发 Father 类的初始化。

常量在编一阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化

public class Const {
    static {
        System.out.println("Const类初始化完成！");
    }

    public static final String HELLO_WORLD = "hello world!";
}

public class Test03 {
    public static void main(String[] args) {
        System.out.println(Const.HELLO_WORLD);
    }
}

测试结果：

hello world!

发现 Const 类也是没有初始化，原因就是常量 HELLO_WORLD 在编译阶段已经被存储在了 Test03 这个类的常量池了，而不是通过引用来传递这个常量了。

上面我们知道了类加载发生在什么时候。

下面我们具体说一下类加载这 5 个小阶段具体在干什么。

类加载的 5 个阶段

加载

这一阶段 JVM 要完成 3 件事：

通过一个类的全限定名来获取定义此类的二进制字节流

我们前面说了，这个二进制字节流不要片面的以为它只有来自我们编译获得的.class 文件，虽然大部分都是，但是它还可能来自网络、数据库、内存或者动态产生！

用什么获取呢？

类加载器。

So wtf is 类加载器？

类加载器就是把 class 文件加载到 JVM 内存中的工具（除了数组类不通过类加载器加载，了解一下即可）。

那也就是说！

我们现在看到的，马上要学习的，就是我们整篇文章最最核心的东西了！

类加载器的种类

怎么类加载器还要分种类？

没错，但为什么要分种类的？那自然是因为类本身是有分类的。

放屁，我写的类众生平等！

没错，我们写的类可能真的众生平等，但是架不住这个世界上有天龙人。

java 世界的天龙人就是 java 自己的核心类库，还有次一级天龙人就是 java 扩展库，然后才轮到我们自己写的应用类。

也就是说：

引导类加载器（Bootstrap Class Loader）：它是类加载器层次结构中的最顶层加载器，负责加载JVM的核心类库，这些类放在<JAVA_HOME>\lib 目录下，如rt.jar中的类。
扩展类加载器（Extension Class Loader）：它负责加载Java的扩展库，通常是<JAVA_HOME>/lib/ext目录下的jar包。
系统类加载器（System Class Loader）：也称为应用类加载器，它根据Java应用的类路径（CLASSPATH）来加载Java类。

以上就是 3 种类加载器，当然我们还有一种自定义的类加载器，但是我理解加载过程现在都费劲，你让我自定义？不可能的，系统类加载器又强大又方便，自定义是不可能自定义的。
这样分类就是说，我们编译得到的 example.class 只能用系统类加载器加载，而高贵的天龙人 java.lang.String 类就用引导类加载器加载。

这时候陈某就不服了：王侯将相宁有种乎？

上来就自己造了一个自己的 java.lang.String 类在本地。

你是 String，我也是 String，谁比谁高贵？

不好意思啊，天龙人有自己的办法，你的 String 不好用，我的好用。

那就是双亲委派模型。