深入剖析Java关键字之final

一、摘要

 我们大家都知道，Java中平时用的比较多的String类型是不可以被继承的，因为String类有final修饰，来看下String类的定义：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence

 很明显有一个final的关键字，那么在Java中，final有哪些作用？到底怎么实现的呢？内存语义是啥呢？接下来的文章将重点分析final的作用以及内存语义等等。

---

二、final关键字的作用

 根据上下文环境，Java的关键字final的含义存在着细微的区别，但通常它指的是“这是无法改变的。”不想做改变可能出于两种理由：设计或效率。由于这两个原因相差很远，所以关键字final有可能被误用。
 基于Java语言规范，我们知道final可以修饰变量、方法以及类，接下来我们分别介绍final修饰它们的作用。

2.1 final修饰变量

 先来看下Java语言规范中关于final修饰变量的描述：

 变量可以被声明为final，而final变量只能被赋值一次。如果对final变量赋值，那么除非在赋值之前该变量是明确未赋值的，否则就是一种编译时错误。
 一旦final变量被赋值，那么它就始终有同一个值。如果一个final变量持有的是对象的引用，那么该对象的状态可以被对象上的操作所修改，但是该变量会始终指向这个对象。这条规则也同样适用于数组，因为数组也是对象。如果一个final变量持有的是指向数组的引用，那么该数组的元素可以被数组上的操作所修改，但是该变量会始终指向这个数组。
 空final是指其声明缺少初始化器的final变量。
 常量变量是指用常量表达式初始化的简单类型或String类型的final变量。
 有三种变量被隐式地声明为final：接口的域、带资源的try语句中的资源，以及多重catch子句中的异常参数。单catch子句的异常参数永远都不会被隐式地声明为final，但是它可以被认为效果等同于final。

 从规范中，可以看出来final变量只能被赋值一次；而变量我们分为基本数据类型和引用类型的变量，对于基本数据类型的变量：final使数值恒定不变；对于引用类型的final变量：final使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象。然后，对象自身却是可以被修改的，Java并未提供使任何对象恒定不变的途径(但可以自己编写类以取得对象恒定不变的效果)。这一限制同样适用于数组，它也是对象。
 一个既是static又是final的域只占据一段不能改变的存储空间。
 下面的例子示范了final域的情况。

import java.util.Random;

class Value {
  int i; // Package access
  public Value(int i) { this.i = i; }
}

public class FinalData {
  private static Random rand = new Random(47);
  private String id;
  public FinalData(String id) {
    this.id = id;
  }
  // Can be compile-time constants:
  private final int valueOne = 9;
  private static final int VALUE_TWO = 99;
  // Typical public constant:
  public static final int VALUE_THREE = 39;
  // Cannot be compile-time constants:
  private final int i4 = rand.nextInt(20);
  static final int INT_5 = rand.nextInt(20);
  private Value v1 = new Value(11);
  private final Value v2 = new Value(22);
  private static final Value VAL_3 = new Value(33);
  // Arrays:
  private final int[] a = { 1, 2, 3, 4, 5, 6 };
  public String toString() {
    return id + ": " + "i4 = " + i4 + ", INT_5 = " + INT_5;
  }
  public static void main(String[] args) {
    FinalData fd1 = new FinalData("fd1");
    //! fd1.valueOne++; // Error: can't change value
    fd1.v2.i++; // Object isn't constant!
    fd1.v1 = new Value(9); // OK -- not final
    for(int i = 0; i < fd1.a.length; i++)
      fd1.a[i]++; // Object isn't constant!
    //! fd1.v2 = new Value(0); // Error: Can't
    //! fd1.VAL_3 = new Value(1); // change reference
    //! fd1.a = new int[3];
    System.out.println(fd1);
    System.out.println("Creating new FinalData");
    FinalData fd2 = new FinalData("fd2");
    System.out.println(fd1);
    System.out.println(fd2);
  }
} /* Output:
fd1: i4 = 15, INT_5 = 18
Creating new FinalData
fd1: i4 = 15, INT_5 = 18
fd2: i4 = 13, INT_5 = 18
*///:~

 由于valueOne和VAL_TWO都是带编译时数值的final基本类型，所以它们二者均可以用作编译器常量，并且没有特别大的区别。VAL_THREE是一种更加典型的对常量进行定义的方式：定义为public，则可以被用于包之外；定义为static，则强调只有一份；定义为final，则说明它是一个常量。请注意，带有恒定初始值(即编译器常量)的final static基本类型全用大写字母命名，并且字与字之间用下划线隔开。
 我们不能因为某数据是final的就认为在编译时可以知道它的值。在运行时使用随机生成的数值来初始化i4和INT_5就说明了这一点。示例部分也展示了将final数值定义为静态和费静态的区别。此区别只有当数值在运行时被初始化时才会显现，这是因为编译器对编译时数值一视同仁。当运行程序时就会看到这个区别。注意，在fd1和fd2中，i4的值是唯一的，但INT_5的值是不可以通过创建第二个FinalData对象而加以改变的。这是因为他是static的，在装载时已被初始化，而不是每次创建新对象时都初始化。
 v1到VAL_3这些变量说明了final引用的意义。正如在main()中所看到的，不能因为v2是final的，就认为无法改变它的值。由于它是一个引用，final意味着无法将v2再次指向另一个新的对象。

2.2 空白final

 Java允许生成“空白final”，所谓空白final是指被声明为final但又未给定初始值的域。无论什么情况，编译器都确保空白final在使用前必须被初始化。但是，空白final在关键字final的使用上提供了更大的灵活性，为此，一个类中的final域就可以做到根据对象而有所不同，却又保持其恒定不变的特性。例如：

class Poppet {
  private int i;
  Poppet(int ii) {
    i = ii;
  }
  public int getI() {
    return i;
  }
}

public class BlankFinal {
  private final int i = 0; // Initialized final
  private final int j; // Blank final
  private final Poppet p; // Blank final reference
  // Blank finals MUST be initialized in the constructor:
  public BlankFinal() {
    j = 1; // Initialize blank final
    p = new Poppet(1); // Initialize blank final reference
  }
  public BlankFinal(int x) {
    j = x; // Initialize blank final
    p = new Poppet(x); // Initialize blank final reference
  }
  public static void main(String[] args) {
    BlankFinal bf1 = new BlankFinal();
    BlankFinal bf2 = new BlankFinal(47);
    System.out.println(bf1.p.getI());
    System.out.println(bf2.p.getI());
  }
} /* Output:
1
47
*///:~

 必须在域的定义处或者每个构造器中用表达式对final进行赋值，这正是final域在使用前总是被初始化的原因所在。

2.3 final参数

 Java允许在参数列表中以声明的方式将参数知名为final。这意味着你无法再方法中更改参数引用所指向的对象：

class Gizmo {
  public void spin() {

  }
}

public class FinalArguments {
  void with(final Gizmo g) {
    //! g = new Gizmo(); // Illegal -- g is final
  }
  void without(Gizmo g) {
    g = new Gizmo(); // OK -- g not final
    g.spin();
  }
  // void f(final int i) { i++; } // Can't change
  // You can only read from a final primitive:
  int g(final int i) {
    return i + 1;
  }
  public static void main(String[] args) {
    FinalArguments bf = new FinalArguments();
    bf.without(null);
    bf.with(null);
  }
} ///:~

 方法f()和g()展示了当基本类型的参数被指明为final时所出现的结果：你可以读参数，但无法修改参数。这一特性主要用来想匿名内部类传递数据。

2.4 final方法

 使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义。这是出于设计的考虑：想要确保在继承中使方法行为保持不变，并且不会被覆盖。
 过去建议使用final方法的第二个原因是效率，在Java的早期实现中，如果将一个方法指明为final，就是同意编译器将针对该方法的所有调用都转为内联调用。当编译器发现一个final方法调用命令时，它会根据自己的谨慎判断，跳过插入程序代码这种正常方式而执行方法调用机制，并且以方法体重的时机代码的副本来替代方法调用。这将消除方法调用的开销。当然，如果一个方法很大，你的程序代码就会膨胀，因而可能看不到内联带来的任何性能提高，因为，所带来的性能提高会因为花费于方法内的时间量而被缩减。
 在最新的Java版本中，虚拟机(特别是hotspot技术)可以探测到这些情况，并优化去掉这些效率反而降低的额外的内联调用，因此不再需要使用final方法来进行优化了。在使用新的Java版本时，应该让编译器和JVM去处理效率问题，只有在想要明确禁止覆盖时，才将方法设置为final的。

fina和private关键字

 类中所有的private方法都隐式地指定为是final的。由于无法取用private方法，所以也就无法覆盖它。可以对private方法添加final修饰词，但这并不给该方法增加任何额外的意义。

2.5 final类

 当将某个类的整体定义为final时（通过将关键字final置于它的定义之前），就表明了你不打算继承该类，而且也不允许别人这样做。换句话说，出于某种考虑，你对该类的设计用不需要做任何变动，或者处于安全的考虑，你不希望它有子类。

class SmallBrain {}

final class Dinosaur {
  int i = 7;
  int j = 1;
  SmallBrain x = new SmallBrain();
  void f() {}
}

//! class Further extends Dinosaur {}
// error: Cannot extend final class 'Dinosaur'
public class Jurassic {
  public static void main(String[] args) {
    Dinosaur n = new Dinosaur();
    n.f();
    n.i = 40;
    n.j++;
  }
} ///:~

 请注意，final类的域可以根据个人的意愿选择为是或不是final。不论类是否被定义为final，相同的规则都适用于定义为final的域。然而，由于final类禁止继承，所以final类中所有的方法都隐式指定为是final的，因为无法覆盖它们。在final类中可以给方法添加final修饰词，但这不会增添任何意义。

---

三、final的原理

---

四、参考引用

Bruce Eckel 《Java编程思想(第四版)》