Java 类加载机制详解

引子

Java 虚拟机的启动是经过引导类加载器 ( Bootstrap Class Loader ) 建立一个初始类  (Initial Class ) 来完成，这个类是由虚拟机的具体实现指定。紧接着，Java虚拟机连接这个初始类，初始化并调用它的 public void main(String[])方法。以后的整个执行过程都是由对此方法的调用开始。执行 main 方法中的 Java 虚拟机指令可能会致使 Java 虚拟机连接另外的一些类或接口，也可能会调用另外的方法。

可能在某种 Java 虚拟机的实现上，初始类会做为命令行参数被提供给虚拟机。固然，虚拟机实现也能够利用一个初始类让类加载器依次加载整个应用。初始类固然也能够选择组合上述的方式来工做。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　—— 以上内容摘自《Java 虚拟机规范》（Java SE 7 版）

在讲类的加载机制前，先来看一道题目：

public class ClassLoaderTest {
    public static void main(String[] args) {
        System.out.println("爸爸的岁数:" + Son.factor);  //入口1 // new Son();  //入口 2
    }
}

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

class Father extends Grandpa {
    static {
        System.out.println("爸爸在静态代码块");
    }
    public static int factor = 25;

    public Father() {
        System.out.println("我是爸爸~");
    }
}

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

    public Son() {
        System.out.println("我是儿子~");
    }
}

上面的代码中分了入口1和入口2， 二者不一样时存在，入口不同，最后输出的结果也是不同的。小伙伴能够思考下这两个入口对于类的初始化有啥不同。下面是具体结果：

入口1 的结果：

爷爷在静态代码块
爸爸在静态代码块
爸爸的岁数:25

入口2 的结果

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

若是之前没有遇到这种问题，如今要你解答确定是很难的。该题考察的就是你对 Java 类加载机制的理解。若是你对 Java 加载机制不理解，那么你是没法解答这道题目的。

对比上面两个结果，能够发现，入口1 都是静态代码的初始化，入口2 既涉及到静态代码的初始化，也涉及到类的初始化。到此你们确定就知道对于静态代码和非静态代码的初始化逻辑是有区别的。

这篇文章，将对 Java 类加载机制的进行讲解，让你之后遇到相似问题不在犯难。

类的加载过程

当 Java 虚拟机将 Java 源码编译为字节码以后，虚拟机即可以将字节码读取进内存，从而进行解析、运行等整个过程，这个过程咱们叫：Java 虚拟机的类加载机制。JVM 虚拟机执行 class 字节码的过程能够分为七个阶段：加载、验证、准备、解析、初始化、使用、卸载。其中加载、检验、准备、初始化和卸载这个五个阶段的顺序是固定的，而解析则未必。为了支持动态绑定，解析这个过程能够发生在初始化阶段以后。

 

 

1. 加载

什么状况下须要开始类加载的第一个阶段：加载。 JAVA虚拟机规范并无进行强制约束，交给虚拟机的具体实现自由把握。

加载阶段是“类加载”过程当中的一个阶段，这个阶段一般也被称做“装载”，在加载阶段，虚拟机主要完成如下3件事情：

1. 经过 "类全名" 来获取定义此类的二进制字节流

2. 将字节流所表明的静态存储结构转换为方法区的运行时数据结构

3. 在 java 堆中生成一个表明这个类的 java.lang.Class 对象，做为方法区这些数据的访问入口（因此咱们可以经过低调用类.getClass() ）

注意这里字节流不必定非得要从一个 Class 文件获取，这里既能够从 ZIP 包中读取（好比从 jar 包和 war 包中读取），也能够在运行时计算生成（动态代理），也能够由其它文件生成（好比将 JSP 文件转换成对应的 Class 类）。加载的信息存储在 JVM 的方法区。

对于数组类来讲，它并无对应的字节流，而是由 Java 虚拟机直接生成的。对于其它的类来讲，Java 虚拟机则须要借助类加载器来完成查找字节流的过程。

若是上面那么多记不住： 请必定记住这句： 加载阶段也就是查找获取类的二进制数据（磁盘或者网络）动做，将类的数据（Class 的信息：类的定义或者结构）放入方法区 （内存）。

一图说明：

2. 验证

验证的主要做用就是确保被加载的类的正确性。也是链接阶段的第一步。说白了也就是咱们加载好的 .class 文件不能对咱们的虚拟机有危害，因此先检测验证一下。他主要是完成四个阶段的验证：

1. 文件格式的验证：验证 .class 文件字节流是否符合 class 文件的格式的规范，而且可以被当前版本的虚拟机处理。这里面主要对魔数、主版本号、常量池等等的校验（魔数、主版本号都是 .class 文件里面包含的数据信息、在这里能够不用理解）。

2. 元数据验证：主要是对字节码描述的信息进行语义分析，以保证其描述的信息符合 java 语言规范的要求，好比说验证这个类是否是有父类，类中的字段方法是否是和父类冲突等等。

3. 字节码验证：这是整个验证过程最复杂的阶段，主要是经过数据流和控制流分析，肯定程序语义是合法的、符合逻辑的。在元数据验证阶段对数据类型作出验证后，这个阶段主要对类的方法作出分析，保证类的方法在运行时不会作出威海虚拟机安全的事。

4. 符号引用验证：它是验证的最后一个阶段，发生在虚拟机将符号引用转化为直接引用的时候。主要是对类自身之外的信息进行校验。目的是确保解析动做可以完成。

对整个类加载机制而言，验证阶段是一个很重要可是非必需的阶段，若是咱们的代码可以确保没有问题，那么咱们就没有必要去验证，毕竟验证须要花费必定的的时间。固然咱们可使用 -Xverfity:none 来关闭大部分的验证。

3. 准备（重点）

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

• 内存分配的对象。Java 中的变量有「类变量」和「类成员变量」两种类型，「类变量」指的是被 static 修饰的变量，而其余全部类型的变量都属于「类成员变量」。在准备阶段，JVM 只会为「类变量」分配内存，而不会为「类成员变量」分配内存。「类成员变量」的内存分配须要等到初始化阶段才开始。

例以下面的代码在准备阶段，只会为 factor 属性分配内存，而不会为 website 属性分配内存。

public static int factor = 3;
public String website = "www.cnblogs.com/chanshuyi";

• 初始化的类型。在准备阶段，JVM 会为类变量分配内存，并为其初始化。可是这里的初始化指的是为变量赋予 Java 语言中该数据类型的零值，而不是用户代码里初始化的值。

例以下面的代码在准备阶段以后，sector 的值将是 0，而不是 3。

public static int sector = 3;

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

public static final int number = 3;

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

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

4. 解析

解析阶段是虚拟机常量池内的符号引用替换为直接引用的过程。

符号引用：符号引用是一组符号来描述所引用的目标对象，符号能够是任何形式的字面量，只要使用时能无歧义地定位到目标便可。符号引用与虚拟机实现的内存布局无关，引用的目标对象并不必定已经加载到内存中。Java 虚拟机明确在 Class 文件格式中定义的符号引用的字面量形式。

直接引用：直接引用能够是直接指向目标对象的指针、相对偏移量或是一个能间接定位到目标的句柄。直接引用是与虚拟机内存布局实现相关的，同一个符号引用在不一样虚拟机实例上翻译出来的直接引用通常不会相同，若是有了直接引用，那引用的目标一定已经在内存中存在。

在解析的阶段，解析动做主要针对7类符号引用进行，它们的名称以及对于常量池中的常量类型和解析报错信息以下：

| 解析动做 | 符号引用 | 解析可能的报错 | | ---------- | ------------------------------- | -----------------------------------------------------------

| | 类或接口 | CONSTANTClassInfo | java.land.IllegalAccessError

| | 字段 | CONSTANTFieldrefInfo | java.land.IllegalAccessError 或 java.land.NoSuchFieldError

| | 类方法 | CONSTANTMethodefInfo | java.land.IllegalAccessError 或 java.land.NoSuchMethodError

| | 接口方法 | CONSTANTInterfaceMethoderInfo | java.land.IllegalAccessError 或 java.land.NoSuchMethodError

| | 方法类型 | CONSTANTMethodTypeInfo |

| | 方法句柄 | CONSTANTMethodhandlerInfo |

| | 调用限定符 | CONSTANTInvokeDynamicInfo | 

解析的整个阶段在虚拟机中仍是比较复杂的，远比上面介绍的复杂的多，可是不少特别细节的东西咱们能够暂时先忽略，先有个大概的认识和了解以后有时间在慢慢深刻了。

5. 初始化（重点）

类初始阶段是类加载过程的最后一步，在上面提到的类加载过程当中，除了加载阶段用户应用程序能够经过自定义类加载器参与以外，其他的动做所有由虚拟机主导和控制。初始化阶段，是真正开始执行类中定义的 Java 程序代码（或者说是字节码）。

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

在这个阶段，JVM 会根据语句执行顺序对类对象进行初始化，通常来讲当 JVM 遇到下面 5 种状况的时候会触发初始化：

1. 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，若是类没有进行过初始化，则须要先触发其初始化。生成这4条指令的最多见的 Java 代码场景是：使用new 关键字实例化对象的时候、读取或设置一个类的静态字段（被 final 修饰、已在编译器把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。

2. 使用 java.lang.reflect 包的方法对类进行反射调用的时候，若是类没有进行过初始化，则须要先触发其初始化。

3. 当初始化一个类的时候，若是发现其父类尚未进行过初始化，则须要先触发其父类的初始化。

4. 当虚拟机启动时，用户须要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类。

5. 当使用 JDK1.7 动态语言支持时，若是一个 java.lang.invoke.MethodHandle 实例最后的解析结果 REF_getstatic，REF_putstatic，REF_invokeStatic 的方法句柄，而且这个方法句柄所对应的类没有进行初始化，则须要先出触发其初始化。

看到上面几个条件你可能会晕了，可是没关系，不须要背，知道一下就好，后面用到的时候回到找一下就能够了。 

注意这里的初始化，并非说创造的类的实例，而是执行了类构造器，简单来讲就是只对静态变量，静态代码块进行初始化。对于构造函数只有在建立实例的时候才会执行。

6. 使用

当 JVM 完成初始化阶段以后，JVM 便开始从入口方法开始执行用户的程序代码。这个阶段也只是了解一下就能够。

7. 卸载

当用户程序代码执行完毕后，JVM 便开始销毁建立的 Class 对象，最后负责运行的 JVM 也退出内存。这个阶段也只是了解一下就能够。

8. 引子题目解答

还记得前面的题目嘛，下面开始分析：

入口1 

也许会有人问为何没有输出「儿子在静态代码块」这个字符串？

这是由于对于静态字段，只有直接定义这个字段的类才会被初始化（执行静态代码块）。所以经过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

对面上面的这个例子，咱们能够从入口开始分析一路分析下去：

• 首先程序到 main 方法这里，使用标准化输出 Son 类中的 factor 类成员变量，可是 Son 类中并无定义这个类成员变量。因而往父类去找，咱们在 Father 类中找到了对应的类成员变量，因而触发了 Father 的初始化。

• 但根据咱们上面说到的初始化的 5 种状况中的第 3 种（当初始化一个类的时候，若是发现其父类尚未进行过初始化，则须要先触发其父类的初始化）。咱们须要先初始化 Father 类的父类，也就是先初始化 Grandpa 类再初始化 Father 类。因而咱们先初始化 Grandpa 类输出：「爷爷在静态代码块」，再初始化 Father 类输出：「爸爸在静态代码块」。

• 最后，全部父类都初始化完成以后，Son 类才能调用父类的静态变量，从而输出：「爸爸的岁数：25」。

入口2 

这里采用 new 进行初始化，因此先进行父类得初始化。先是执行静态变量初始化。子类建立对象的同时会先创造父类的对象，所以必须先调用父类的构造方法。

变更

这里我作了一些改变：

public class ClassLoaderTest {
    public static void main(String[] args) {
        // System.out.println("爸爸的岁数:" + Son.factor);  //入口1
         new Son(3);  //入口 2
    }

}

class Grandpa {
    int s = 3;
  
    public Grandpa(int s) {
        System.out.println("我是爷爷~" );
    }
    static {
        System.out.println("爷爷在静态代码块");
    }
}    

class Father extends Grandpa {
    static {
        System.out.println("爸爸在静态代码块");
    }
    public static int factor = 25;

    public Father(int s) {
        //super(s);
        System.out.println("我是爸爸~");
    }
}

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

    public Son(int s ) {
        super(s);
        System.out.println("我是儿子~");
    }
}

这里的变更是，父类子类都只有一个有参构造函数，在初始化子类得时候，不显示的调用父类的构造函数，运行结果以下：

爷爷在静态代码块 Exception in thread "main" 
爸爸在静态代码块
儿子在静态代码块
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Implicit super constructor Grandpa() is undefined. Must explicitly invoke another constructor

    at Father.<init>(ClassLoaderTest.java:27)
    at Son.<init>(ClassLoaderTest.java:39)
    at ClassLoaderTest.main(ClassLoaderTest.java:5)

简单来讲，若是子类构造函数不显示调用父类的构造函数，这时候在初始化子类得时候，就会去父类寻找无参构造函数，若是父类只定义了有参构造函数，没有无参构造函数，就会报错。所以通常来讲最好是显示调用，又或者多定义几种不一样的构造函数，方便在不一样场景下调用。

类加载器

把类加载阶段的 "经过一个类的全限定名来获取描述此类的二进制字节流" 这个动做交给虚拟机以外的类加载器来完成。这样的好处在于，咱们能够自行实现类加载器来加载其余格式的类，只要是二进制字节流就行，这就大大加强了加载器灵活性。

系统自带的类加载器分为三种：

1. 启动类加载器。其它的类加载器都是 java.lang.ClassLoader 的子类，启动类加载器是由 C++ 实现的，没有对应的 Java 对象，所以在 Java 中只能用 null 代替。启动类加载器加载最为基础，最为重要的类，如 JRE 的 lib 目录下 jar 包中的类；扩展类加载器的父类是启动类加载器，它负责加载相对次要，但又通用的类，如 JRE 的 lib/ext 目录下jar包中的类

2. 扩展类加载器。Java核心类库提供，负责加载java的扩展库（加载 JAVA_HOME/jre/ext/*.jar 中的类），开发者能够直接使用扩展类加载器。

3. 应用程序类加载器。Java核心类库提供。应用类加载器的父类加载器则是扩展类加载器，它负责加载应用程序路径下的类。开发者能够直接使用这个类加载器，若应用程序中没有定义过本身的类加载器，java 应用的类都是由它来完成加载的。

具体关系以下：

 

 

双亲委派机制工做过程：

若是一个类加载器收到了类加载器的请求，它首先不会本身去尝试加载这个类，而是把这个请求委派给父加载器去完成。每一个层次的类加载器都是如此，所以全部的加载请求最终都会传送到 Bootstrap 类加载器(启动类加载器)中，只有父类加载反馈本身没法加载这个请求(它的搜索范围中没有找到所需的类)时，子加载器才会尝试本身去加载。

双亲委派模型的优势：java类随着它的加载器一块儿具有了一种带有优先级的层次关系.

例如类 java.lang.Object 它存放在 rt.jart 之中，不管哪个类加载器都要加载这个类.最终都是双亲委派模型最顶端的 Bootstrap 类加载器去加载.所以Object类在程序的各类类加载器环境中都是同一个类.相反.若是没有使用双亲委派模型.由各个类加载器自行去加载的话.若是用户编写了一个称为 "java.lang.Object" 的类，并存放在程序的 ClassPath 中。那系统中将会出现多个不一样的Object类，java类型体系中最基础的行为也就没法保证，应用程序也将会一片混乱。

这里也能够用代码验证下：

public class ClassLoaderTest {
    public static void main(String[] args) {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        System.out.println(loader);  
        System.out.println(loader.getParent());  
        System.out.println(loader.getParent().getParent());  
    }
}

输出结果为：

sun.misc.Launcher$AppClassLoader@2a139a55
sun.misc.Launcher$ExtClassLoader@7852e922
null

跟前面的描述是一致的。启动类加载器是由 C++ 实现的，没有对应的 Java 对象，所以在 Java 中只能用 null 代替。

自定义类加载器

一、为何要自定义ClassLoader

由于系统的 ClassLoader 只会加载指定目录下的 class 文件,若是你想加载本身的 class 文件，那么就能够自定义一个 ClassLoader.

并且咱们能够根据本身的需求，对 class 文件进行加密和解密。

2. 如何自定义ClassLoader

新建一个类继承自 java.lang.ClassLoader 重写它的 findClass 方法。将 class 字节码数组转换为 Class 类的实例。调用 loadClass 方法加载便可

代码实战：

先是定义一个自定义类加载器

package com.hello.test;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class MyClassLoader extends ClassLoader {
    // 指定路径
    private String path ;
    
    public MyClassLoader(String classPath){
        path=classPath;
    }
 
    /**
     * 重写findClass方法
     * @param name 是咱们这个类的全路径
     * @return
     * @throws ClassNotFoundException
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class log = null;
        // 获取该class文件字节码数组
        byte[] classData = getData();
 
        if (classData != null) {
            // 将class的字节码数组转换成Class类的实例
            log = defineClass(name, classData, 0, classData.length);
        }
        return log;
    }
 
    /**
     * 将class文件转化为字节码数组
     * @return
     */
    private byte[] getData() {
 
        File file = new File(path);
        if (file.exists()){
            FileInputStream in = null;
            ByteArrayOutputStream out = null;
            try {
                in = new FileInputStream(file);
                out = new ByteArrayOutputStream();
 
                byte[] buffer = new byte[1024];
                int size = 0;
                while ((size = in.read(buffer)) != -1) {
                    out.write(buffer, 0, size);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    in.close();
                } catch (IOException e) {
 
                    e.printStackTrace();
                }
            }
            return out.toByteArray();
        }else{
            return null;
        }
    }
}

能够再 getData 里面作不少事情 ，好比加密解密之类的 都是能够的。

接着建立一个试验 class :

package com.hello.test;

public class Log {
    public static void main(String[] args) {
        System.out.println("load Log class successfully from log " );
    }
}

执行命令行 javac Log.java 生成咱们的 Log.class 文件:

最后就是进行加载：

package com.hello.test;

import java.lang.reflect.Method;

public class ClassLoaderTest {
    public static void main(String[] args) {
         // 这个类class的路径,本身复制本身电脑的路径
        String classPath = "/Users/yourname/Documents/workspace-sts-3.9.6.RELEASE/HelloWorld/src/Log.class";
 
        MyClassLoader myClassLoader = new MyClassLoader(classPath);
        // 类的全称，对应包名
        String packageNamePath = "com.hello.test.Log";
        try {
        // 加载Log这个class文件
            Class<?> Log = myClassLoader.loadClass(packageNamePath);
            System.out.println("类加载器是:" + Log.getClassLoader());
            // 利用反射获取main方法
            Method method = Log.getDeclaredMethod("main", String[].class);
            Object object = Log.newInstance();
            String[] arg = {"ad"};
            method.invoke(object, (Object) arg);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

输出结果以下：

能够看到是委托父类进行加载的。 到此，关于类加载器的内容就说完了。

巩固练习

最后咱们再来看一道升级事后的题目：

public class Book {
 
    static int amount1 = 112;

    static Book book = new Book();  // 入口1


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


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

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

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

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

　　　　 System.out.println("amount=" + amount + ",amount1=" + amount1);

    }
    
    int price = 110;
    static int amount = 112;
    // static Book book = new Book(); // 入口2
}

 入口1 的结果

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

入口2 的结果

书的静态代码块
书的普通代码块
书的构造方法
price=110, amount=112, amount1=112
书的静态方法
amount=112, amount1=112

 入口1 分析

在上面两个例子中，由于 main 方法所在类并无多余的代码，咱们都直接忽略了 main 方法所在类的初始化。

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

1. 当 JVM 在准备阶段的时候，便会为类变量分配内存和进行初始化。此时，咱们的 book 实例变量被初始化为 null，amount，amout1 变量被初始化为 0。

2. 当进入初始化阶段后，由于 Book 方法是程序的入口，根据咱们上面说到的类初始化的五种状况的第四种（当虚拟机启动时，用户须要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类）。因此 JVM 会初始化 Book 类，即执行类构造器 。

3. JVM 对 Book 类进行初始化首先是执行类构造器（按顺序收集类中全部静态代码块和类变量赋值语句就组成了类构造器 ），

4. 后执行对象的构造器（按顺序收集成员变量赋值和普通代码块，最后收集对象构造器，最终组成对象构造器 ）。

对于入口1，执行类构造器发现 book 实例是静态变量，因而就会执行普通代码块，再去执行 book 的构造函数。执行完后，从新回到执行类构造器的路上，对剩下的静态变量进行初始化。

 入口2 分析

入口2 的变化就是将静态实例初始化移到了最后。从而保证优先执行类构造器，再去进行对象初始化过程。

变例 

假如把入口1，2 都注释掉，这回结果会怎么样：

书的静态代码块
书的静态方法
amount=112, amount1=112

能够发现，最终只有类构造器获得了执行。

方法论

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

• 肯定类变量的初始值。在类加载的准备阶段，JVM 会为类变量初始化零值，这时候类变量会有一个初始的零值。若是是被 final 修饰的类变量，则直接会被初始成用户想要的值。

• 初始化入口方法。当进入类加载的初始化阶段后，JVM 会寻找整个 main 方法入口，从而初始化 main 方法所在的整个类。当须要对一个类进行初始化时，会首先初始化类构造器（），以后初始化对象构造器（）。

• 初始化类构造器。JVM 会按顺序收集类变量的赋值语句、静态代码块，最终组成类构造器由 JVM 执行。

• 初始化对象构造器。JVM 会按照收集成员变量的赋值语句、普通代码块，最后收集构造方法，将它们组成对象构造器，最终由 JVM 执行。

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

 

参考文章

类加载机制-深刻理解jvm

Java类加载机制，你理解了吗？

JVM基础系列第7讲：JVM 类加载机制

Java内存管理-掌握虚拟机类加载机制（四）