java的关键字final的含义通常指“这是无法改变的”，不想改变出于两种理由。
1、设计。
2、效率
谈论一些用到final的三种情况。数据、方法和类
1、数据
有时候数据恒定不变是由意义的，
例如1 一个永不改变编译时的常量。
例如2：一个在运行时被初始化的值，而你不希望它被改变。
在java中这些常量必须是基本类型，以关键字final表示。在编译时执行计算，减轻运行时负担。对基本类型final使数值恒定不变。而对于对象引用，final使引用恒定不变，但是对象自身是可以修改的，java并没有提供对象恒定不变的途径。
即是static又是final的域，将用大小表示，并使用下划线分割单词。
package pdmtest.cl;
public class FinalData {
// Can be compile-time constants
final int i1 = 9;
static final int I2 = 99;
// Typical public constant:
public static final int I3 = 39;
// Cannot be compile-time constants:
final int i4 = (int) (Math.random() * 20);
static final int i5 = (int) (Math.random() * 20);
Value v1 = new Value();
final Value v2 = new Value();
static final Value v3 = new Value();
// ! final Value v4; // Pre-Java 1.1 Error:
// no initializer
// Arrays:
final int[] a = { 1, 2, 3, 4, 5, 6 };
public void print(String id) {
v3.i = (int) (Math.random() * 20);
v2.i = (int) (Math.random() * 20);
System.out.println(id + ": " + "i4 = " + i4 + ", i5 = " + i5+ ", v3 = "+v3.i+ ", v2 = "+v2.i);
}
public static void main(String[] args) {
FinalData fd1 = new FinalData();
// ! fd1.i1++; // Error: can't change value
fd1.v2.i++; // Object isn't constant!
fd1.v1 = new Value(); // OK -- not final
for (int i = 0; i < fd1.a.length; i++)
fd1.a[i]++; // Object isn't constant!
// ! fd1.v2 = new Value(); // Error: Can't
// ! fd1.v3 = new Value(); // change handle
// ! fd1.a = new int[3];
fd1.print("fd1");
FinalData fd2 = new FinalData();
fd1.print("fd1");
fd2.print("fd2");
}
}
output
fd1: i4 = 18, i5 = 9, v3 = 2, v2 = 18
fd1: i4 = 18, i5 = 9, v3 = 17, v2 = 5
fd2: i4 = 2, i5 = 9, v3 = 3, v2 = 6
空白final
Java 1.1 允许我们创建“空白final”，它们属于一些特殊的字段。尽管被声明成final，但却未得到一个
初始值。无论在哪种情况下，空白final 都必须在实际使用前得到正确的初始化。
class Poppet { }
class BlankFinal {
final int i = 0; // Initialized final
final int j; // Blank final
final Poppet p; // Blank final handle
// Blank finals MUST be initialized
// in the constructor:
BlankFinal() {
j = 1; // Initialize blank final
p = new Poppet();
}
BlankFinal(int x) {
j = x; // Initialize blank final
p = new Poppet();
}
public static void main(String[] args) {
BlankFinal bf = new BlankFinal();
}
} ///:~
现在强行要求我们对final 进行赋值处理——要么在定义字段时使用一个表达 式，要么在每个构建器中
final参数
java允许在参数列表中以声明的方式将参数指明为final，意味着你无法改变参数引用所指向的对象。
package pdmtest.cl;
public class FinalArguments {
void with(final Gizmo g){
//g = new Gizmo();//final object 不可以赋值
}
void f(final int i){
//i=2;不可以赋值
}
int g(final int x){
return x+1;
}
public static void main(String[] args) {
FinalArguments f = new FinalArguments();
System.out.println(f.g(1));
Gizmo g = new Gizmo();
f.with(g);
}
}
这一特性主要是向匿名内部类传递数据。
final方法
使用final方法有两个原因。
第一个原因把方法锁定，防止任何类修改它的含义。出于设计考虑。
第二个原因是效率。将方法指明给final就是同意编译器针对该方法的所有调用都转为内嵌调用。
final类
当将某个类设计为final时，表明你不打算集成该类，而且也不允许别人这么做。
将类定义成final 后，结果只是禁止进行继承——没有更多的限制。然
而，由于它禁止了继承，所以一个final 类中的所有方法都默认为final
package pdmtest.cl;
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++;
}
}
