阿里面试题系列：工作5年，第一次这么清醒的理解final关键字？

怎么入门数据库编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《阿里面试题系列：工作5年，第一次这么清醒的理解final关键字？》，涉及到MySQL、Java、程序员，有需要的可以收藏一下

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

面试考察点

考察目的：了解面试者对Java基础知识的理解

考察人群：工作1-5年，工作年限越高，对于基础知识理解的深度就越高。

背景知识

   public static void main(String[] args) {   }

}

   上述程序运行得到如下错误：   ```txt   java: 无法从最终org.example.cl03.TClass进行继承

1. 被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实例对象中的

   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);    }}

   具体思路是，把被修饰了

   Field modifiers = name.getClass().getDeclaredField("modifiers");modifiers.setAccessible(true);modifiers.setInt(name, name.getModifiers() & ~Modifier.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（匿名内部类）

   

   通过反编译来看一下

   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方法中的形参

   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 关键字的一些好处：

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

   问题解答

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

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

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

   另外，

   final

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

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

   问题总结

   恰恰是平时经常使用的一些工具或者技术，所涉及到的知识点越多。

   就这个问题来说，在面试时的考察点太多了，比如：

   1. 如何破坏final规则
   2. 带static和final修饰的属性，可以被修改吗？
   3. final是否可以解决可见性问题，以及它是如何解决的？

   因此，要想在面试时从容应对，一定要具备体系化的技术理解，避免面试时各种”不清楚“、”不了解“之类的尴尬！

   如果本文对您有帮助，欢迎关注和点赞；如果您有任何建议也可留言评论或私信，您的支持是我坚持创作的动力。需要设计模式、源码等相关学习资料可以戳这里免费领取资料

   

   好了，本文到此结束，带大家了解了《阿里面试题系列：工作5年，第一次这么清醒的理解final关键字？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多数据库知识！