Java 关键字 final

final

方法

  • final 修饰的方法不可被重写。它可以防止任何继承类修改方法的意义和实现
  • 而且使用 final 修饰方法的执行效率一般高于普通方法,这里不得不提一下 Java 的内联(inline)机制

​ 当我们调用方法时,实际上是将程序的执行转移到该方法所在的内存地址上,将该方法执行完后,再返回到执行该方法前的位置,这种转移操作要求在转移前保存当前的数据以及内存地址,在执行完后再恢复现场,继续按照转移前的地址执行,也就是通常所说的压栈和出栈(这段文字有点绕口,简单来说,比如 A 方法在执行到第 10 行的时候调用了 B 方法,JVM 会先保存 A 方法当前数据和执行地址,然后跳转到 B 方法所在的内存地址执行 B 方法,执行完后,再返回 A 方法第十行继续执行),因此,函数调用有一定时间和空间方面的开销,对于函数体积不大,但是频繁调用的函数来说,这个开销就会放大。
​ 因此,对于这种函数体积不大又频繁调用的的方法,我们可以通过内联函数来提升运行效率,当我们对一个方法使用 final 修饰时,这个方法就有可能成为内联函数(JVM 会根据方法的执行效率决定是否内联)。

  • 内联前:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A {
int value;
public final int get(){
return value;
}
}

public class B {
public void sum() {
A a = new A();
//调用a的get方法
int x = a.get();
}
}
  • 内联后:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A {
int value;
public final int get(){
return value;
}
}

public class B {
public void sum() {
A a = new A();
//此处将get方法展开为内联函数
int x = a.value;
}
}

  • final 修饰一个类时,表明其为最终类,它不能被继承
  • 并且类中所有的属性和方法都默认是 final 类型,如 StringInteger 等包装类均为 final
  • 方法默认被修饰为 final ,这时方法的内联起到作用了, 这种空间置换时间的策略需要一个平衡点(break-even),如果一个方法过于大,copy 的副本数量过于多,那么这样的平衡就会被打破,优化的目的反而失去了意义

变量

  • 修饰基本类型变量时,变量的值不可改变

  • 修饰引用变量时,变量指向的对象地址不可改变

  • 这里还涉及到了一个类似 C 语言的宏替换概念,由于 final 修饰的 String 变量不可更改,所以,当一个 String 变量被 final 修饰时,这个值在编译期就可以确定,所有将该变量直接替换为它对应的值,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class test {
public static void main(String[] args) {
final String a = "hello";
String b = "hello";
final String c = "world";
String d = "hello" + "world";
String e = a + c;
String f = b + c;
String g = "helloworld";

// 在编译期,由于 a 和 c 的值已经确定并且不会再更改(效果同 d),
// 所以 e 的值能够在编译期就确定下来,直接指向了常量区的 g,前两个均为 true
System.out.println(g == d);//true
System.out.println(g == e);//true

// 由于 b 值的不确定性,所以在编译期不能确定其值,只能在运行时确认
System.out.println(g == f);//false
}
}

参数

  • final 修饰的参数有一个只读的属性,即可以读取该参数,但是无法更改参数的值,同修饰变量一样,当参数为基本类型时,该参数的值不可改变;当参数为引用类型时,参数的引用地址不可改变。

final 的内存语义

  • volatile 可以禁止指令重排序,final 同样有这样的作用,对于 final 域,编译器和处理器要遵守两个重排序规则

在构造函数内对一个 final 域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。

  • 意思是说,在对象引用为任意线程可见之前,对象的 final 域已经被正确初始化了(JVM 禁止把 final 域的写重排序到构造函数之外,要保证该效果,还要确保 final 引用没有从构造函数溢出)。

初次读一个包含 final 域的对象的引用,与随后初次读这个 final 域,这两个操作之间不能重排序。

  • 意思是说,在读一个对象的 final 域之前,一定会先读包含这个 final 域的对象的引用。

  • 对于内存语义这块,还需要结合代码去理解,参考《Java 并发编程的艺术》一书 3.6 节。

参考:

https://zhuanlan.zhihu.com/p/60889552

https://www.jianshu.com/p/f68d6ef2dcf0