两道面试题让你透彻解析Java类加载机制

时间  2019-11-08
标签 面试 让你 透彻 解析 java 加载 机制 栏目 快乐工作 繁體版
原文   原文链接

在许多Java面试中，咱们常常会看到关于Java类加载机制的考察，例以下面这道题：java

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

请写出最后的输出字符串。web

正确答案是：面试

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

我相信不少同窗看到这个题目以后，表情是崩溃的，彻底不知道从何入手。有的甚至遇到了几回，仍然没法找到正确的解答思路。bash

**其实这种面试题考察的就是你对Java类加载机制的理解。**若是你对Java加载机制不理解，那么你是没法解答这道题目的。这篇文章，我将经过对Java类加载机制的讲解，让你掌握解答此类题目的方法。网络

Java类加载机制的七个阶段

当咱们的Java代码编译完成后，会生成对应的 class 文件。接着咱们运行java Demo命令的时候，咱们实际上是启动了JVM 虚拟机执行 class 字节码文件的内容。而 JVM 虚拟机执行 class 字节码的过程能够分为七个阶段：加载、验证、准备、解析、初始化、使用、卸载。测试

加载

下面是对于加载过程最为官方的描述。spa

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

其实加载阶段用一句话来讲就是：**把代码数据加载到内存中。**这个过程对于咱们解答这道问题没有直接的关系，但这是类加载机制的一个过程，因此必需要提一下。cdn

验证

当 JVM 加载完 Class 字节码文件并在方法区建立对应的 Class 对象以后，JVM 便会启动对该字节码流的校验，只有符合 JVM 字节码规范的文件才能被 JVM 正确执行。这个校验过程大体能够分为下面几个类型：对象

  • **JVM规范校验。**JVM 会对字节流进行文件格式校验，判断其是否符合 JVM 规范，是否能被当前版本的虚拟机处理。例如：文件是不是以 0x cafe bene开头，主次版本号是否在当前虚拟机处理范围以内等。
  • **代码逻辑校验。**JVM 会对代码组成的数据流和控制流进行校验，确保 JVM 运行该字节码文件后不会出现致命错误。例如一个方法要求传入 int 类型的参数，可是使用它的时候却传入了一个 String 类型的参数。一个方法要求返回 String 类型的结果，可是最后却没有返回结果。代码中引用了一个名为 Apple 的类，可是你实际上却没有定义 Apple 类。

当代码数据被加载到内存中后，虚拟机就会对代码数据进行校验，看看这份代码是否是真的按照JVM规范去写的。这个过程对于咱们解答问题也没有直接的关系，可是了解类加载机制必需要知道有这个过程。

准备（重要）

当完成字节码文件的校验以后，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 修饰的类变量，其可能在初始化阶段或者运行阶段发生变化，因此就没有必要在准备阶段对它赋予用户想要的值。

解析

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

其实这个阶段对于咱们来讲也是几乎透明的，了解一下就好。

初始化（重要）

到了初始化阶段，用户定义的 Java 程序代码才真正开始执行。在这个阶段，JVM 会根据语句执行顺序对类对象进行初始化，通常来讲当 JVM 遇到下面 5 种状况的时候会触发初始化：

  • 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，若是类没有进行过初始化，则须要先触发其初始化。生成这4条指令的最多见的Java代码场景是：使用new关键字实例化对象的时候、读取或设置一个类的静态字段（被final修饰、已在编译器把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。
  • 使用 java.lang.reflect 包的方法对类进行反射调用的时候，若是类没有进行过初始化，则须要先触发其初始化。
  • 当初始化一个类的时候，若是发现其父类尚未进行过初始化，则须要先触发其父类的初始化。
  • 当虚拟机启动时，用户须要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
  • 当使用 JDK1.7 动态语言支持时，若是一个 java.lang.invoke.MethodHandle实例最后的解析结果 REF_getstatic,REF_putstatic,REF_invokeStatic 的方法句柄，而且这个方法句柄所对应的类没有进行初始化，则须要先出触发其初始化。

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

使用

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

卸载

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

实战分析

了解了Java的类加载机制以后，下面咱们经过几个例子测试一下。

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

思考一下，上面的代码最后的输出结果是什么？

最终的输出结果是：

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

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

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

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

  • 首先程序到 main 方法这里，使用标准化输出 Son 类中的 factor 类成员变量，可是 Son 类中并无定义这个类成员变量。因而往父类去找，咱们在 Father 类中找到了对应的类成员变量，因而触发了 Father 的初始化。
  • 但根据咱们上面说到的初始化的 5 种状况中的第 3 种，咱们须要先初始化 Father 类的父类，也就是先初始化 Grandpa 类再初始化 Father 类。因而咱们先初始化 Grandpa 类输出：「爷爷在静态代码块」，再初始化 Father 类输出：「爸爸在静态代码块」。
  • 最后，全部父类都初始化完成以后，Son 类才能调用父类的静态变量，从而输出：「爸爸的岁数：25」。

咱们再来看一下下面这个例子，看看输出结果是啥。

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 类的初始化，而 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 执行 Book 类的成员变量，再搜集普通代码块，最后执行类的构造方法，因而其执行语句能够表示以下：

int price = 110;
{
    System.out.println("书的普通代码块");
}
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 执行。 若是在初始化 main 方法所在类的时候遇到了其余类的初始化，那么继续按照初始化类构造器、初始化对象构造器的顺序继续初始化。如此反复循环，最终返回 main 方法所在类。

看完了上面的解析以后，再去看看开头那道题是否是以为简单多了呢。不少东西就是这样，掌握了必定的方法和知识以后，本来困难的东西也变得简单许多了。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程