阿里面试题系列(工作5年,第一次这么清醒的理解final关键字())
面试题:用过final关键字吗?它有什么作用面试考察点 考察目的:了解面试者对Java基础知识的理解
考察人群:工作1-5年,工作年限越高,对于基础知识理解的深度就越高。
背景知识
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) {}
}
上述程序运行得到如下错误:```txtjava: 无法从最终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来修饰变量,就能达到定义常量的效果。
- 如果是引用类型的变量,则在对其初始化之后便不能再让其指向另一个对象。
- 在定义时初始化属性的值
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; }}
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
知识点扩展反射无法修改被final和static同时修饰的变量
上述代码理论上来说应该是下面这种写法,因为通过反射修改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
把上面的代码修改如下。
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.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 org.example.cl03.TCCClass.main(TCCClass.java:13)
那么被final和static同时修饰的属性,能否被修改呢?答案是可以的!【阿里面试题系列(工作5年,第一次这么清醒的理解final关键字())】修改代码如下:
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关键字提高了性能,JVM和Java应用都会缓存final变量(实际就是常量池)
- final变量可以安全的在多线程环境下进行共享,而不需要额外的同步开销
面试题:用过final关键字吗?它有什么作用回答:final关键字表示不可变,它可以修饰在类、方法、成员变量中。
- 如果修饰在类上,则表示该类不允许被继承
- 修饰在方法上,表示该方法无法被重写
- 修饰在变量上,表示该变量无法被修改,而且JVM会隐性定义为一个常量。
final
修饰的关键字,还可以避免因为指令重排序带来的可见性问题,原因是,final遵循两个重排序规则- 构造函数内,对一个 final 变量的写入,与随后把这个被构造对象的引用赋值给一个变量,这两个操作之间不可重排序。
- 首次读一个包含 final 变量的对象,与随后首次读这个 final 变量,这两个操作之间不可以重排序。
就这个问题来说,在面试时的考察点太多了,比如:
- 如何破坏final规则
- 带static和final修饰的属性,可以被修改吗?
- final是否可以解决可见性问题,以及它是如何解决的?
如果本文对您有帮助,欢迎关注和点赞;如果您有任何建议也可留言评论或私信,您的支持是我坚持创作的动力。 需要设计模式、源码等相关学习资料可以戳这里免费领取资料
文章图片
推荐阅读
- 阿菘的ScalersTalk第五轮新概念朗读持续力训练Day15|阿菘的ScalersTalk第五轮新概念朗读持续力训练Day15 20191025
- 蓝桥杯试题
- 阿修罗|仨头镶钻,也哄不住5岁小孩
- 日知图录85——印度阿萨姆红茶
- 【阿不娘厨房?炒米粉】
- 戏剧教育阿提斯师资培训在安徽阜阳举办
- 往前跑,向前冲??——勇气读书会推荐图书《阿甘正传》
- iOS面试题--基础
- 《阿飞正传》影评
- 怪谈清道夫(第二章)