一、摘要
我们大家都知道，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编程思想(第四版)》
