关键字之final

final关键字之final Data

概括来说final的含义为：This cannot be changed即不能被改变。

下面就data，methods以及class三个方面来进行说明。

final data

with a primitive ,final makes value a constant...

final修饰基本数据类型的变量时，表示的是一个常量即在定义时就必须赋值。

with an object reference ,final makes the reference a constant...

final修饰对象引用时,这个引用便是一个常量，即引用一旦被初始化指向一个对象便不能指向另外一个对象，然而对象本身是可以改变的。

java does not provide a way to make any arbitrary object a constant...

java不能使任何一个对象变成常数(constant)

实验代码（来自于thinking in java）

在整理时略有改动...

package _20120202;

import java.util.Random;

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;
	}
	//can be compile-time constants...
	private final int valueOne = 9;
	private static final int ValueTwo = 99;
	//typical public constant...
	public static final int ValueThree = 39;
	//cannot be compile-time constants...
	private final int i4 = rand.nextInt(20);
	private final int int_5 = rand.nextInt(20);
	private Value v1 = new Value(11);
	private final Value v2 = new Value(22);
	private static final Value v3 = 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:cannot change value..
		fd1.v2.i++;//the object is not constant...
		fd1.v1= new Value(9);
		for(int i = 0;i < fd1.a.length;i++){
			fd1.a[i]++;//Object isn't constant...
		}
		/**
		 * Error cannot change the references...
		 */
		//fd1.v2 = new Value(0);
		//fd1.v3 = new Value(1);
		//fd1.a = new int[8];//cannot point to another object...
		System.out.println(fd1);
		System.out.println("creating new FinalData:");
		FinalData fd2 = new FinalData("fd2");
		System.out.println(fd1);
		System.out.println(fd2);
		
	}
}

程序的运行结果如下：

fd1: i4 = 15 ,int_5 = 18

creating new FinalData:

fd1: i4 = 15 ,int_5 = 18

fd2: i4 = 13 ,int_5 = 18

 

程序中ValueThree，final是说此变量是一个常量，static强调唯一性...v2的i值可以改变但是不能重新被赋给新的对象（fd1.v2 = new Value(0);）说明了当一个引用为final时只是说明该引用不能重新只相信的对象，但是对象本身的值是可以改变的。

以下用程序说明Static final 与final的区别：

代码如下：

package _20120202;

import java.util.Random;


/**
 * show the difference between the static final and final...
 * @author yolanda
 *
 */
public class FinalDataTest {

	private static Random rand = new Random(2000);
	private final int id = rand.nextInt(30);
	private static final int share = rand.nextInt(30);
	public String toString(){
		return "the object's information is "+" id = "+id+" share : "+share;
	}
	public static void main(String[] args){
		FinalDataTest fd1 = new FinalDataTest();
		FinalDataTest fd2 = new FinalDataTest();
		System.out.println(fd1);
		System.out.println(fd2);
	}
}

运行结果：

the object's information is  id = 29 share : 29

the object's information is  id = 4 share : 29

结论：

有结果可知两个对象的id不同，但是两个对象的share是相同的。share变量是static  final的，属于编译时常量，static表示在加载的时候只生成一次，并不会再每次创建对象的时候都会创建。

 

final关键字之blank final

java允许创建blank final即变量声明为final但是没有进行初始化，但是在任何时候变量在使用前都必须要进行初始化。

blank final的存在使得final的用法很灵活，它可以让每一个类中的final变量不同的同时也保持了这个变量的不变性。

实验代码（来自于thinking in java）

package _20120202;

class Poppet{
	private int i;
	public Poppet(int i){
		this.i = i;
	}
	public int getI(){
		return this.i;
	}
}
public class BlankFinal {
	private final int i = 0;
	private final int j;
	private final Poppet p;
	
	public BlankFinal(){
		this.j = 1;
		this.p = new Poppet(1);
	}
	
	public BlankFinal(int x){
		this.j = x;
		this.p = new Poppet(x);
	}
	
	public String toString(){
		return "j = "+this.j+" p = "+this.p.getI();
	}
	public static void main(String[] args){
	
		BlankFinal bf1 = new BlankFinal();
		BlankFinal bf2 = new BlankFinal(4);
		
		System.out.println(bf1);
		System.out.println(bf2);
	}
}

程序结果：

j = 1 p = 1

j = 4 p = 4

blank final必须在每一个构造函数中进行赋值，这样保证在使用之前变量已经被初始化...

 

final关键字之final arguments

参数用final修饰则说明该参数你只能读取而不能修改...与final data相同

final关键字之final methods

用final修饰方法有两点好处：1.在继承中保持函数的行为不被改变2.提高函数的运行效率，因为final的methods调用是内联调用(inline calls)。final的方法不能被子类重置(override)。

final关键字之final and private

如果类中的方法是private那么该方法前面加final对于这个函数本身的性质没有任何影响。

final关键字之final classes

final class不允许被继承，也不能被改变，final类的函数默认都是final类型的

final关键字之final caution（暂时没有看懂，待以后解决）