写点什么

两道面试题,带你解析 Java 类加载机制,零基础也能看得懂

用户头像
极客good
关注
发布于: 刚刚

例如下面的代码在准备阶段之后,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("我是爸爸~");


}


}


cla


【一线大厂Java面试题解析+核心总结学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开:qq.cn.hn/FTf 免费领取
复制代码


ss Son extends Father


{


static


{


System.out.println("儿子在静态代码块");


}


public Son()


{


System.out.println("我是儿子~");


}


}


public class InitializationDemo


{


public static void main(String[] args)


{


new Son(); //入口


}


}


输出结果是:


爷爷在静态代码块


爸爸在静态代码块


儿子在静态代码块


我是爷爷~


我是爸爸~


我是儿子~


虽然我们只是实例化了 Son 对象,但是当子类初始化时会带动父类初始化,因此输出结果就如上面所示。


文章首发于[【博客园-陈树义】](


),点击跳转到原文[《两道面试题,带你解析 Java 类加载机制》](


)


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


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


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

用户头像

极客good

关注

还未添加个人签名 2021.03.18 加入

还未添加个人简介

评论

发布
暂无评论
两道面试题,带你解析Java类加载机制,零基础也能看得懂