面试题:用过final关键字吗?它有什么作用
面试考察点
考察目的:了解面试者对Java基础知识的理解
考察人群:工作1-5年,工作年限越高,对于基础知识理解的深度就越高。
背景知识
final
关键字大家都不陌生,但是要达到深度理解,还是欠缺了一些。我们从三个方面去理解final
关键字。
final
关键字的基本用法- 深度理解
final
关键字 final
关键字的内存屏障语义
final的基本用法
final
关键字,在Java中可以修饰类、方法、变量。
- 被final修饰的类,表示这个类不可被继承,final类中的成员变量可以根据需要设为final,并且final修饰的类中的所有成员方法都被隐式指定为final方法.
在使用final修饰类的时候,要注意谨慎选择,除非这个类真的在以后不会用来继承或者出于安全的考虑,尽量不要将类设计为final类。
\```java public final class TClass {
public final String test(){ return "true";}
} public class TCCClass extends TClass{
public static void main(String[] args) { }
}
上述程序运行得到如下错误: ```txt java: 无法从最终org.example.cl03.TClass进行继承
- 被final修饰的方法,表示该方法无法被重写.其中
private
方法会被隐式的指定为final
方法。
class SuperClass{ protected final String getName() { return “supper class”; } @Override public String toString() { return getName(); }}classSubClass extends SuperClass{ protected String getName() { return “sub class”; }}
上述代码运行会得到如下错误:
java: org.example.cl03.TCCClass中的test()无法覆盖org.example.cl03.TClass中的test() 被覆盖的方法为final - 被final修饰的成员变量是用得最多的地方。
- 对于一个final变量,如果是基本数据类型的变量,则其数值一旦在初始化之后便不能更改;final修饰的变量能间接实现常量的功能,而常量是全局的、不可变的,因此我们同时使用static和final来修饰变量,就能达到定义常量的效果。
- 如果是引用类型的变量,则在对其初始化之后便不能再让其指向另一个对象。
被final修饰的变量的初始化
- 在定义时初始化属性的值
public class TCCClass { private final String name; public static void main(String[] args) { }}
上述代码在运行时会提示如下错误
java: 变量 name 未在默认构造器中初始化
修改成下面的方式即可。
public class TCCClass { private final String name="name";} - 在构造方法中赋值
public class TCCClass { private final String name; public TCCClass(String name){ this.name=name; }}
能够在构造方法中赋值的原因是:对于一个普通成员属性赋值时,必须要先通过构造方法实例化该对象。因此作为该属性唯一的访问入口,JVM允许在构造方法中给final
修饰的属性赋值。这个过程并没有违反final
的原则。当然如果被修饰final
关键字的属性已经初始化了值,是无法再使用构造方法重新赋值的。
反射破坏final规则
基于上述final关键字的基本使用描述,可以知道final
修饰的属性是不可变的。
但是,通过反射机制,可以破坏final
的规则,代码如下
public class TCCClass { private final String name="name"; public static void main(String[] args) throws Exception { TCCClass tcc=new TCCClass(); System.out.println(tcc.name); Field name=tcc.getClass().getDeclaredField("name"); name.setAccessible(true); name.set(tcc,"mic"); System.out.println(name.get(tcc)); }}
打印结果如下:
namemic
知识点扩展
上述代码理论上来说应该是下面这种写法,因为通过反射修改tcc实例对象中的name
属性后,应该通过实例对象直接打印出name
的结果。
public static void main(String[] args) throws Exception { TCCClass tcc=new TCCClass(); System.out.println(tcc.name); Field name=tcc.getClass().getDeclaredField("name"); name.setAccessible(true); name.set(tcc,"mic"); System.out.println(tcc.name); //here}
但是实际输出结果后,发现tcc.name
打印的结果没有变化?
原因是:JVM在编译时期做的深度优化机制, 就把final类型的String进行了优化, 在编译时期就会把String处理成常量,导致打印结果不会发生变化。
为了避免这种深度优化带来的影响,我们还可以把上述代码修改成下面这种形式
public class TCCClass { private final String name=(null == null ? "name" : ""); public static void main(String[] args) throws Exception { TCCClass tcc=new TCCClass(); System.out.println(tcc.name); Field name=tcc.getClass().getDeclaredField("name"); name.setAccessible(true); name.set(tcc,"mic"); System.out.println(tcc.name); }}
打印结果如下:
namemic
反射无法修改被final和static同时修饰的变量
把上面的代码修改如下。
public class TCCClass { private static final String name=(null == null ? "name" : ""); public static void main(String[] args) throws Exception { TCCClass tcc=new TCCClass(); System.out.println(tcc.name); Field name=tcc.getClass().getDeclaredField("name"); name.setAccessible(true); name.set(tcc,"mic"); System.out.println(tcc.name); }}
执行结果,执行之后会报出如下异常, 因为反射无法修改同时被static final修饰的变量:
Exception in thread "main" java.lang.IllegalAccessException: Can not set static final java.lang.String field org.example.cl03.TCCClass.name to java.lang.String at 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 org.example.cl03.TCCClass.main(TCCClass.java:13)
那么被final和static同时修饰的属性,能否被修改呢?答案是可以的!
修改代码如下:
public class TCCClass { private static final String name=(null == null ? "name" : ""); public static void main(String[] args) throws Exception { TCCClass tcc=new TCCClass(); System.out.println(tcc.name); Field name=tcc.getClass().getDeclaredField("name"); name.setAccessible(true); Field modifiers = name.getClass().getDeclaredField("modifiers"); modifiers.setAccessible(true); modifiers.setInt(name, name.getModifiers() & ~Modifier.FINAL); name.set(tcc,"mic"); modifiers.setInt(name, name.getModifiers() & ~Modifier.FINAL); System.out.println(tcc.name); }}
具体思路是,把被修饰了final
关键字的name
属性,通过反射的方式去掉final
关键字,代码实现
Field modifiers = name.getClass().getDeclaredField("modifiers");modifiers.setAccessible(true);modifiers.setInt(name, name.getModifiers() & ~Modifier.FINAL);
接着通过反射修改name
属性,修改成功后,再使用下面代码把final
关键字加回来
modifiers.setInt(name, name.getModifiers() & ~Modifier.FINAL);
为什么局部内部类和匿名内部类只能访问final变量
在了解这个问题之前,我们先来看下面这段代码
public static void main(String[] args) { } public void test(final int b) { final int a = 10; new Thread(){ public void run() { System.out.println(a); System.out.println(b); }; }.start(); }}
这段代码被编译后,会生成两个文件: FinalExample.class和FinalExample$1.class(匿名内部类)
通过反编译来看一下FinalExample$1.class
这个类
class FinalExample$1 extends Thread { FinalExample$1(FinalExample 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 变量的写与读。
- 写的重排序规则可以保证,在对象引用对任意线程可见之前,对象的 final 变量已经正确初始化了,而普通变量则不具有这个保障;
- 读的重排序规则可以保证,在读一个对象的 final 变量之前,一定会先读这个对象的引用。如果读取到的引用不为空,根据上面的写规则,说明对象的 final 变量一定以及初始化完毕,从而可以读到正确的变量值。
如果 final 变量的类型是引用型,那么构造函数内,对一个 final 引用的对象的成员域的写入,与随后在构造函数外把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。实际上这也是为了保证 final 变量在对其他线程可见之前,能够正确的初始化完成。
关于指令重排序相关的内容,就不在本篇文章中做展开,在后续的面试题中,会做详细的分析。
final 关键字的好处
下面为使用 final 关键字的一些好处:
- final关键字提高了性能,JVM和Java应用都会缓存final变量(实际就是常量池)
- final变量可以安全的在多线程环境下进行共享,而不需要额外的同步开销
问题解答
面试题:用过final关键字吗?它有什么作用
回答:final关键字表示不可变,它可以修饰在类、方法、成员变量中。
- 如果修饰在类上,则表示该类不允许被继承
- 修饰在方法上,表示该方法无法被重写
- 修饰在变量上,表示该变量无法被修改,而且JVM会隐性定义为一个常量。
另外,final
修饰的关键字,还可以避免因为指令重排序带来的可见性问题,原因是,final遵循两个重排序规则
- 构造函数内,对一个 final 变量的写入,与随后把这个被构造对象的引用赋值给一个变量,这两个操作之间不可重排序。
- 首次读一个包含 final 变量的对象,与随后首次读这个 final 变量,这两个操作之间不可以重排序。
问题总结
恰恰是平时经常使用的一些工具或者技术,所涉及到的知识点越多。
就这个问题来说,在面试时的考察点太多了,比如:
- 如何破坏final规则
- 带static和final修饰的属性,可以被修改吗?
- final是否可以解决可见性问题,以及它是如何解决的?
因此,要想在面试时从容应对,一定要具备体系化的技术理解,避免面试时各种”不清楚“、”不了解“之类的尴尬!
如果本文对您有帮助,欢迎关注和点赞;如果您有任何建议也可留言评论或私信,您的支持是我坚持创作的动力。需要设计模式、源码等相关学习资料可以戳这里免费领取资料
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。