2021Java常见面试题：两道面试题，带你解析Java类加载机制

{

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

我相信很多同学看到这个题目之后，表情是崩溃的，完全不知道从何入手。有的甚至遇到了几次，仍然无法找到正确的解答思路。



其实这种面试题考察的就是你对Java类加载机制的理解。



如果你对Java加载机制不理解，那么你是无法解答这道题目的。



所以这篇文章，我先带大家学习Java类加载的基础知识，然后再实战分析几道题目让大家掌握思路。



下面我们先来学习下Java类加载机制的七个阶段。



Java类加载机制的七个阶段

--------------



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



### 加载



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



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



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



### 验证



当 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 对象，但是当子类初始化时会带动父类初始化，因此输出结果就如上面所示。



文章首发于[【博客园-陈树义】](https://gitee.com/vip204888/java-p7)，点击跳转到原文[《两道面试题，带你解析Java类加载机制》](https://gitee.com/vip204888/java-p7)

=========================================================================================================================================================



我们仔细来分析一下上面代码的执行流程：



*   首先在入口这里我们实例化一个 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();

最后

手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都都可提供源文件给每位爱学习的朋友，获取链接：戳这里免费下载

类的初始化又会带动 Father 、Grandpa 类的初始化，从而执行对应类中的静态代码块。因此会输出：「爷爷在静态代码块」、「爸爸在静态代码块」、「儿子在静态代码块」。

• 当 Son 类完成初始化之后，便会调用 Son 类的构造方法，而 Son 类构造方法的调用同样会带动 Father、Grandpa 类构造方法的调用，最后会输出：「我是爷爷_{」、「我是爸爸}」、「我是儿子~」。

下面我们举一个稍微复杂点的例子。

public class Book {

    public static void main(String[] args) {

        staticFunction();

    }



    static Book book = new Book();



### 最后

手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都都可提供源文件给每位爱学习的朋友，**[获取链接：戳这里免费下载](https://gitee.com/vip204888/java-p7)**

[外链图片转存中...(img-gF85q1yY-1628128034158)]