面试考察点

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

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

背景知识

final

final

1. final

   关键字的基本用法
2. 深度理解

   final

   关键字

3. final

   关键字的内存屏障语义

final的基本用法

final

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

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

   public final class TClass {
   
   public final String test(){
   return "true";
   }
   }
   public class TCCClass extends TClass{
   
   public static void main(String[] args) {
   
   }
   }

   上述程序运行得到如下错误：

   java: 无法从最终org.example.cl03.TClass进行继承

2. 被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

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

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

被final修饰的变量的初始化

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

   public class TCCClass {
   private final String name;
   public static void main(String[] args) {
   
   }
   }

   上述代码在运行时会提示如下错误

   java: 变量 name 未在默认构造器中初始化

   修改成下面的方式即可。

   public class TCCClass {
   private final String name="name";
   }

2. 在构造方法中赋值

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

打印结果如下：

name
mic

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

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

name
mic

反射无法修改被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)

修改代码如下：

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

run

a

b

但是这样一来，还是存在一个问题，就是

test

这样就达不到原本的意图和要求。为了解决这个问题，java编译器就限定必须将变量

a

b

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

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

问题解答

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

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

另外，

final

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

问题总结

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

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

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

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

关注[跟着Mic学架构]公众号，获取更多精品原创