面试题：final、finally、finalize的区别

背景知识

final/finally在工作中几乎无时无刻不再使用，因此即便是没有系统化的梳理这个问题，也能回答出一些内容。

但是finalize就接触得非常少，接下来我们对这几个关键字逐一进行分析。

finial 关键字

final关键字大家都不陌生，但是要达到深度理解，还是欠缺了一些。我们从三个方面去理解final关键字。

1. final关键字的基本用法
2. 深度理解final关键字
3. final关键字的内存屏障语义

基本用法

final关键字，在Java中可以修饰类、方法、变量。

1. 被final修饰的类，表示这个类不可被继承，final类中的成员变量可以根据需要设为final，并且final修饰的类中的所有成员方法都被隐式指定为final方法.

   在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。

   public final class FinalTest {public final String test() {return "true";}}
   

   然后创建一个类继承该类，我们可以发现如下错误。
   

2. 被final修饰的方法，表示该方法无法被重写.其中private方法会被隐式的指定为final方法。

   class SuperClass {protected final String getName() {return "supper class";}@Overridepublic String toString() {return getName();}
   }
   

3. 被final修饰的成员变量是用得最多的地方。

• 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；final修饰的变量能间接实现常量的功能，而常量是全局的、不可变的，因此我们同时使用static和final来修饰变量，就能达到定义常量的效果。

• 如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

被final修饰的变量的初始化

1. 在定义时初始化属性的值

   class SuperClass {private final String name;protected final String getName() {return "supper class";}@Overridepublic String toString() {return getName();}
   }
   

   上述代码会出现错误，由于我们没有对数据进行初始化。
   
   对name字段进行赋值即可。

2. 在构造方法中赋值

   除了直接赋值，我们也可以在构造方法中对属性赋值。

   class SuperClass {private final String name;public SuperClass(String name) {this.name = name;}protected final String getName() {return "supper class";}@Overridepublic String toString() {return getName();}
   }
   

   ​ 能够在构造方法中赋值的原因是：对于一个普通成员属性赋值时，必须要先通过构造方法实例化该对象。因此作为该属性唯一的访问入口，JVM允许在构造方法中给final修饰的属性赋值。这个过程并没有违反final的原则。当然如果被修饰final关键字的属性已经初始化了值，是无法再使用构造方法重新赋值的。

反射破坏final规则

基于上述final关键字的基本使用描述，可以知道final修饰的属性是不可变的。

但是，通过反射机制，可以破坏final的规则，代码如下：

class SuperClass {private final String name = "name";public static void main(String[] args) throws Exception {SuperClass superClass = new SuperClass();System.out.println(superClass.name);Field field = superClass.getClass().getDeclaredField("name");field.setAccessible(true);field.set(superClass, "chen");System.out.println(field.get(superClass));}
}

结果如下：

name
chen

知识点扩展

上述代码理论上来说应该是下面这种写法，因为通过反射修改tcc实例对象中的name属性后，应该通过实例对象直接打印出name的结果。

public static void main(String[] args) throws Exception {SuperClass superClass = new SuperClass();System.out.println(superClass.name);Field field = superClass.getClass().getDeclaredField("name");field.setAccessible(true);field.set(superClass, "chen");//System.out.println(field.get(superClass));System.out.println(superClass.name);
}

但是实际输出结果后，发现superClass.name打印的结果没有变化？

原因是：JVM在编译时期做的深度优化机制, 就把final类型的String进行了优化, 在编译时期就会把String处理成常量，导致打印结果不会发生变化。

为了避免这种深度优化带来的影响，我们还可以把上述代码修改成下面这种形式

	//处理jvm带来的深度优化private final String name=(null == null ? "name" : "");public static void main(String[] args) throws Exception {SuperClass superClass = new SuperClass();System.out.println(superClass.name);Field field = superClass.getClass().getDeclaredField("name");field.setAccessible(true);field.set(superClass, "chen");//System.out.println(field.get(superClass));System.out.println(superClass.name);}

打印结果如下:

name
chen

反射无法修改被final和static同时修饰的变量

把上面的代码修改如下。

private static final String name=(null == null ? "name" : "");

会出现如下报错：

Exception in thread "main" java.lang.IllegalAccessException: Can not set static final java.lang.String field com.example.javastudy.interview.SuperClass.name to java.lang.Stringat sun.reflect.UnsafeFieldAccessorImpl.throwFinalFieldIllegalAccessException(UnsafeFieldAccessorImpl.java:76)at sun.reflect.UnsafeFieldAccessorImpl.throwFinalFieldIllegalAccessException(UnsafeFieldAccessorImpl.java:80)at sun.reflect.UnsafeQualifiedStaticObjectFieldAccessorImpl.set(UnsafeQualifiedStaticObjectFieldAccessorImpl.java:77)at java.lang.reflect.Field.set(Field.java:764)at com.example.javastudy.interview.SuperClass.main(SuperClass.java:26)

那么被final和static同时修饰的属性，能否被修改呢？答案是可以的！

修改代码如下：

//处理jvm带来的深度优化
private static final String name = (null == null ? "name" : "");public static void main(String[] args) throws Exception {SuperClass superClass = new SuperClass();System.out.println(superClass.name);Field field = superClass.getClass().getDeclaredField("name");field.setAccessible(true);// 去除 final关键字 实现 对 static 及 final 属性修改Field modifiers = field.getClass().getDeclaredField("modifiers");modifiers.setAccessible(true);modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);field.set(superClass, "chen");modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);System.out.println(superClass.name);
}

具体思路是，把被修饰了final关键字的name属性，通过反射的方式去掉final关键字，接着通过反射修改name属性，修改成功后，再使用下面代码把final关键字加回来

		modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);field.set(superClass, "chen");modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);

为什么局部内部类和匿名内部类只能访问final变量

在了解这个问题之前，我们在之前的类中添加下面这段代码：

public void test(final int b) {final int a = 10;new Thread(){public void run() {System.out.println(a);System.out.println(b);};}.start();}

这段代码被编译后，会生成两个文件: SuperClass.class和 SuperClass$1.class（匿名内部类）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sWcvKSNr-1636088510015)(final、finally、finalize的区别.assets/image-20211105112752171.png)]

通过反编译来看一下SuperClass$1.class这个类

class SuperClass$1 extends Thread {SuperClass$1(SuperClass this$0, int var2, int var3) {this.this$0 = this$0;this.val$a = var2;this.val$b = var3;}public void run() {System.out.println(this.val$a);System.out.println(this.val$b);}
}

我们看到匿名内部类FinalExample$1的构造器含有三个参数，一个是指向外部类对象的引用，另外两个是int型变量，很显然，这里是将变量test方法中的形参b，以及常量a以参数的形式传进来，对匿名内部类中的拷贝（变量a和b的拷贝）进行赋值初始化。

也就是说，在run方法中访问的变量a和b，是局部变量a和b的一个副本，为什么这么设计？

在test方法中，有可能test方法执行结束且a和b的声明周期也结束了，但是Thread这个匿名内部类可能还未执行完，那么在Thread中的run方法中继续使用局部变量a和b就会有问题。但是又要实现这样的效果，怎么办呢？所以Java采用了复制的手段来解决这个问题。

但是这样一来，还是存在一个问题，就是test方法中的成员变量与匿名内部类Thread中的成员变量的副本出现数据不一致怎么办？

这样就达不到原本的意图和要求。为了解决这个问题，java编译器就限定必须将变量a和b限制为final变量，不允许对变量a和b进行更改（对于引用类型的变量，是不允许指向新的对象），这样数据不一致性的问题就得以解决了。

另外，如果我们这么写也是允许的，jvm会隐式给a和b增加final关键字。

public void test(int b) {int a = 10;new Thread(){public void run() {System.out.println(a);System.out.println(b);};}.start();
}

final防止指令重排

final关键字，还能防止指令重排序带来的可见性问题；

对于final变量，编译器和处理器都要遵守两个重排序规则：

• 构造函数内，对一个 final 变量的写入，与随后把这个被构造对象的引用赋值给一个变量，这两个操作之间不可重排序。
• 首次读一个包含 final 变量的对象，与随后首次读这个 final 变量，这两个操作之间不可以重排序。

实际上这两个规则也正是针对 final 变量的写与读。

1. 写的重排序规则可以保证，在对象引用对任意线程可见之前，对象的 final 变量已经正确初始化了，而普通变量则不具有这个保障；
2. 读的重排序规则可以保证，在读一个对象的 final 变量之前，一定会先读这个对象的引用。如果读取到的引用不为空，根据上面的写规则，说明对象的 final 变量一定以及初始化完毕，从而可以读到正确的变量值。

如果 final 变量的类型是引用型，那么构造函数内，对一个 final 引用的对象的成员域的写入，与随后在构造函数外把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。实际上这也是为了保证 final 变量在对其他线程可见之前，能够正确的初始化完成。

final 关键字的好处

• final关键字提高了性能，JVM和Java应用都会缓存final变量（实际就是常量池）
• final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销

问题解答

面试题：用过final关键字吗？它有什么作用

回答：final关键字表示不可变，它可以修饰在类、方法、成员变量中。

1. 如果修饰在类上，则表示该类不允许被继承
2. 修饰在方法上，表示该方法无法被重写
3. 修饰在变量上，表示该变量无法被修改，而且JVM会隐性定义为一个常量。

另外，final修饰的关键字，还可以避免因为指令重排序带来的可见性问题，原因是，final遵循两个重排序规则

1. 构造函数内，对一个 final 变量的写入，与随后把这个被构造对象的引用赋值给一个变量，这两个操作之间不可重排序。
2. 首次读一个包含 final 变量的对象，与随后首次读这个 final 变量，这两个操作之间不可以重排序。

finally关键字

finally关键字用在try语句块后面，它的常用形式是：

try{}catch(){}finally{}

finally语句块中的代码，无论try或者catch代码块中是否有异常，finally语句块中的代码一定会被执行，所以它一般用于清理工作、关闭链接等类型的语句。

它的特点：

1. finally语句一定会伴随try语句出现。
2. try语句不能单独使用，必须配合catch语句或finally语句。
3. try语句可以单独与catch语句一起使用，也可以单独与finally语句一起使用，也可以三者一起使用。

finally 实战思考

为了加深大家对于finally关键字的理解，我们来看下面这段代码。

思考一下，下面这段代码，打印的结果分别是多少？

public class FinallyExample {public static void main(String arg[]) {System.out.println(getNumber(0));System.out.println(getNumber(1));System.out.println(getNumber(2));System.out.println(getNumber(4));}public static int getNumber(int num) {try {int result = 2 / num;return result;} catch (Exception exception) {return 0;} finally {if (num == 0) {return -1;}if (num == 1) {return 1;}}}}

正确答案分别是：

1. -1：传入num=0，此时会报错java.lang.ArithmeticException: / by zero。因此进入到catch捕获该异常。由于finally语句块一定会被执行，因此进入到finally语句块，返回-1。
2. 1：传入num=1，此时程序运行正常，由于finally语句块一定会被执行，因此进入到finally代码块，得到结果1。
3. 1：传入num=2，此时程序运行正常，result=1，由于finally语句块一定会被执行，因此进入到finally代码块，但是finally语句块并没有触发对结果的修改，所以返回结果为1。
4. 0：传入num=4，此时程序运行正常，result=0(因为2/4=0.5，转换为int后得到0)，由于finally语句块一定会被执行，因此进入到finally代码块，但是finally语句块并没有触发对结果的修改，所以返回结果为0。

什么情况下finally不会执行

finally代码块，是否有存在不会被执行的情况呢？

System.exit()

来看下面这段代码：

public class FinallyExample {public static void main(String arg[]){System.out.println(getNumber(0));}public static int getNumber(int num){try{int result=2/num;return result;}catch(Exception exception){System.out.println("触发异常执行");System.exit(0);return 0;}finally{System.out.println("执行finally语句块");}}
}

在catch语句块中，增加了System.exit(0)代码，执行结果如下

触发异常执行

可以发现，在这种情况下，并没有执行finally语句块。

该方法用来结束当前正在运行的Java JVM。如果 status 是非零参数，那么表示是非正常退出。

1. System.exit(0) ：将整个虚拟机里的内容都关掉，内存都释放掉！正常退出程序。
2. System.exit(1) ：非正常退出程序
3. System.exit(-1) ：非正常退出程序

由于当前JVM已经结束了，因此程序代码自然不能继续执行。

守护线程被中断

先来看下面这段代码：

public class FinallyExample {public static void main(String[] args) {Thread t = new Thread(new Task());t.setDaemon(true); //置为守护线程t.start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException("the "+Thread.currentThread().getName()+" has been interrupted",e);}}}class Task implements Runnable {@Overridepublic void run() {System.out.println("执行 run()方法");try {System.out.println("执行 try 语句块");TimeUnit.SECONDS.sleep(5); //阻塞5s} catch (InterruptedException e) {System.out.println("执行 catch 语句块");throw new RuntimeException("the " + Thread.currentThread().getName() + " has been interrupted", e);} finally {System.out.println("执行 finally 语句块");}}
}

运行结果如下:

执行 run()方法
执行 try 语句块

从结果发现，finally语句块中的代码并没有被执行？为什么呢？

守护线程的特性是：只要JVM中没有任何非守护线程在运行，那么虚拟机会kill掉所有守护线程从而终止程序。换句话说，就是守护线程是否正在运行，都不影响JVM的终止。

在虚拟机中，垃圾回收线程以及main线程都是守护线程。

在上述运行的程序中，执行逻辑描述如下：

1. 线程t是守护线程，它开启一个任务Task执行，该线程t在main方法中执行，并且在睡眠1s之后，main方法执行结束
2. Task是一个守护线程的执行任务，该任务睡眠5s。

基于守护线程的特性，main和task都是守护线程，因此当main线程执行结束后，并不会因为Task这个线程还未执行结束而阻塞。而是在等待1s后，结束该进程。

这就使得Task这个线程的代码还未执行完成，但是JVM进程已结束，所以finally语句块没有被执行。

finally执行顺序

基于上述内容的理解，是不是自认为对finally关键字掌握很好了？那我们在来看看下面这个问题。

重新创建类，方便查看字节码。

这段代码的执行结果是多少呢？

public class FinallyExample2 {public int add() {int x = 1;try {return ++x;} catch (Exception e) {System.out.println("执行catch语句块");++x;} finally {System.out.println("执行finally语句块");++x;}return x;}public static void main(String[] args) {FinallyExample2 t = new FinallyExample2();int y = t.add();System.out.println(y);}}

上述程序运行的结果是：2

这个结果应该有点意外，因为按照finally的语义，首先执行try代码块，++x后得到的结果应该是2， 接着再执行finally语句块，应该是在2的基础上再+1，得到结果是3，那为什么是2？

这边设计到字节码的相关问题，就不详细阐述，我们可以大致理解为：如果 try 语句里有 return，那么代码的行为如下：

1. 如果有返回值，就把返回值保存到局部变量中
2. 执行 jsr 指令跳到 finally 语句里执行
3. 执行完 finally 语句后，返回之前保存在局部变量表里的值

finalize方法

finalize 方法定义在 Object 类中，其方法定义如下：

protected void finalize() throws Throwable {
}

当一个类在被回收期间，这个方法就可能会被调用到。

它有使用规则是：

1. 当对象不再被任何对象引用时，GC会调用该对象的finalize()方法
2. finalize()是Object的方法，子类可以覆盖这个方法来做一些系统资源的释放或者数据的清理
3. 可以在finalize()让这个对象再次被引用，避免被GC回收；但是最常用的目的还是做cleanup
4. Java不保证这个finalize()一定被执行；但是保证调用finalize的线程没有持有任何user-visible同步锁。
5. 在finalize里面抛出的异常会被忽略，同时方法终止。
6. 当finalize被调用之后，JVM会再一次检测这个对象是否能被存活的线程访问得到，如果不是，则清除该对象。也就是finalize只能被调用一次；也就是说，覆盖了finalize方法的对象需要经过两个GC周期才能被清除。

问题回答

面试题：final、finally、finalize的区别

回答：

1. final用来修饰类、方法、属性，被final修饰的类，表示该类无法被继承，被final修饰的属性，表示该属性无法被修改，被final修饰的方法，表示该方法无法被重写

2. finally，它和try语句块组成一个完整的语法，表示一定会被执行的代码块，当然也有方式可以破坏它的执行特性

3. 1. 通过System.exit
   2. 守护线程的终止

4. finalize方法，是一个类被回收期间可能会被调用的方法。