D 的个人博客

但行好事莫问前程

  menu
417 文章
3446695 浏览
4 当前访客
ღゝ◡╹)ノ❤️
/            

再识 Java 的 final 关键字

在 Java 中，我们一般用 final 关键字来定义类字段常量，防止类继承、方法覆写。但其实我们也应该尽可能地使用 final 关键字来修饰方法参数与局部变量。

因为这样做可以使代码更易读，能让阅读者清楚地知道该参数/变量是不会在被重赋值的，也可以让编译器更好地帮助我们优化生成的字节码。

代码可读性

方法的输入参数是不应该被重新赋值的，细节见重构 Remove Assignments to Parameters。

对于局部变量也应该尽可能地使用 final 来修饰，例如折半查找返回中间索引的方法（摘自 Sun JDK）：

private static <T>
    int indexedBinarySearch(List<? extends Comparable<? super T>> list, T key)
    {
        int low = 0;
        int high = list.size()-1;

 1    while (low &lt;= high) {
 2        int mid = (low + high) &gt;&gt;&gt; 1;
 3        Comparable&lt;? super T&gt; midVal = list.get(mid);
 4        int cmp = midVal.compareTo(key);
 5
 6        if (cmp &lt; 0)
 7            low = mid + 1;
 8        else if (cmp &gt; 0)
 9            high = mid - 1;
10        else
11            return mid; // key found
12    }
13    return -(low + 1);  // key not found
14}</pre>



其中 mid 标记了中间值索引，midValue 是中间值，cmp 是中间值与待查找值 key 的比较结果，这三个变量在 while 迭代中都是不会被重新赋值的。


另外，入参也没有在方法内部被重赋值。所以改成下面这样是更好的选择：


private static <T>
    int indexedBinarySearch(final List<? extends Comparable<? super T>> list, final T key)
    {
        int low = 0;
        int high = list.size()-1;

 1    while (low &lt;= high) {
 2        final int mid = (low + high) &gt;&gt;&gt; 1;
 3        final Comparable&lt;? super T&gt; midVal = list.get(mid);
 4        final int cmp = midVal.compareTo(key);
 5
 6        if (cmp &lt; 0)
 7            low = mid + 1;
 8        else if (cmp &gt; 0)
 9            high = mid - 1;
10        else
11            return mid; // key found
12    }
13    return -(low + 1);  // key not found
14}</pre>



这样能够给予代码阅读者更多的上下文信息，能更精确地表达实现语义，也有利于避免实现时由于疏忽造成的错误。


当然，有人也许会说太多 final 会造成视觉干扰，影响阅读。其实，这只是个视觉习惯而已 ;-)


编译内联优化


通常，编译器会内联常量表达式，比如方法：


    private void test() {
        long i = 88250;
        long j = 219;

1    long k = i + j;
2
3    System.out.println(k);
4}</pre>



编译生成的字节码：

    private void test();
      Code:
       0:   ldc2_w  #2; //long 88250l
       3:   lstore_1
       4:   ldc2_w  #4; //long 219l
       7:   lstore_3
       8:   lload_1
       9:   lload_3
       10:  ladd
       11:  lstore  5
       13:  getstatic       #6; //Field java/lang/System.out:Ljava/io/PrintStream;
       16:  lload   5
       18:  invokevirtual   #7; //Method java/io/PrintStream.println:(J)V
       21:  return

很显然，long i = 88250，long j = 219 以及 long k = i + j 这三句语句可以写为常量表达式。改写后的 test 方法：


    private void test() {
        final long i = 88250;
        final long j = 219;

1    final long k = i + j;
2
3    System.out.println(k);
4}</pre>



编译生成的字节码：

    private void test();
      Code:
       0:   getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
       3:   ldc2_w  #3; //long 88469l
       6:   invokevirtual   #5; //Method java/io/PrintStream.println:(J)V
       9:   return



从上面我们可以看出，编译器生成字节码时做了内联处理，即


    

  • 在引用某常量的地方进行值替换
    • 

  • 移除原常量
    • 



当然，除了上面提到的使用 final 修饰变量外，final 也可用于类、方法和字段。


修饰方法时要注意内联条件，不是加了 final 编译器就一定会对该方法进行内联，因为至少要考虑二进制兼容性。


结论


final 关键字能更有效地表达设计与实现意图，能够有助于减少编码错误，所以我们应该尽可能地使用 final。


参考