还是TIJ里把final解释得最彻底

以前我是这样理解final的：

final表示最终的，它可以修饰变量，方法和类。当它修饰变量的时候，这个变量不能再被与修改（注：错误的，至少不全）；当它修饰方法时，该方法不能被override（重写）；当它修饰类时，该类不能再派生出子类。

回头看了TIJ， 才知道自己的理解其实很片面，或者很肤浅，下面是TIJ里对final阐述的总结：


final表示“这样东西是不允许改动的”的意思。它可以修饰数据，方法，以及类。

[b]final数据[/b]

对primitive来说，final会将这个值定义成常量，在定义时赋值；既是static又是final的数据成员会只占据一段内存，并且不可修改。
对reference来说，final的意思则是这个reference是常量，初始化的时候，一旦将reference连接到某个对象，那么它就再也不能指别的对象了，但这个对象本身是可以修改的，Java没有提供将某个对象当作常量的方法。

[b]final 方法[/b]
禁止派生类修改该方法！

[b]final和private[/b]
Private方法已经隐含有final的意思，因为外部是不能访问private的，也就不存在覆写它。

[b]final类[/b]
出于类的设计考虑，它再也不需要作修改了；或者从安全角度出发，不希望它再派生出子类。
final类的数据可以是final的，也可以不是final的，这由自己决定；对于它的方法，由于final类禁止了继承，覆写方法已经不可能，所以所有的方法都隐含地变成final的了！

下面是TIJ4里关于final的一些示例：

/*************************** "final" 修饰参数示例/***************************/

class Gizmo
{
	public void spin()	{}
}

public class FinalArguments
{
	void with(final Gizmo g)
	{
		// ! g = new Gizmo(); 
		// 非法，g 是引用常量是不能指向新的对象的
	}
	void without(Gizmo g)
	{
		g = new Gizmo(); // 没有问题
		g.spin();
	}

	// void f(final int i) { i++; } 
	// 只能读取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);
	}
} // /:~

/*************************** final成员变量的示例 ***************************/
import java.util.*;
import static net.mindview.util.Print.*;

class Value
{
	int i; // 包访问限制
	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;	}

	// 编译时常量
	private final int valueOne = 9;
	private static final int VALUE_TWO = 99;

	// 典型的公共访问常量
	public static final int VALUE_THREE = 39;

	// 非编译时常量
	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);

	// 数组
	private final int[] a = { 1, 2, 3, 4, 5, 6 };

	//重写toString()方法
	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];
		print(fd1);
		print("Creating new FinalData");
		FinalData fd2 = new FinalData("fd2");
		print(fd1);
		print(fd2);
	}
}/* Output:
fd1: i4 = 15, INT_5 = 18
Creating new FinalData
fd1: i4 = 15, INT_5 = 18
fd2: i4 = 13, INT_5 = 18
*///:~

/*************************** final，private的示例 ***************************/

class WithFinals
{
	// 虽然加上了final，但效果和只有private一样，private+final是无意义的 
	private final void f()
	{
		print("WithFinals.f()");
	}
	// private在其它类中本身就看不见，也就无法重写，相当于隐含了final
	private void g()
	{
		print("WithFinals.g()");
	}
}

class OverridingPrivate extends WithFinals
{
	private final void f()
	{
		print("OverridingPrivate.f()");
	}
	private void g()
	{
		print("OverridingPrivate.g()");
	}
}

class OverridingPrivate2 extends OverridingPrivate
{
	public final void f()
	{
		print("OverridingPrivate2.f()");
	}
	public void g()
	{
		print("OverridingPrivate2.g()");
	}
}

public class FinalOverridingIllusion
{
	public static void main(String[] args)
	{
		OverridingPrivate2 op2 = new OverridingPrivate2();
		op2.f();
		op2.g();
		// You can upcast:
		OverridingPrivate op = op2;
		// But you can't call the methods:
		// ! op.f();
		// ! op.g();
		// Same here:
		WithFinals wf = op2;
		// ! wf.f();
		// ! wf.g();
	}
}
/* Output:
OverridingPrivate2.f()
OverridingPrivate2.g()
*///:~