[Java]"final"关键字的用法和知识点总结(上半部分)

<script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> </script>

关键字final

  

---

   根据上下文环境, Java的关键字final的含义存在着细微的区别,但通常它是指"这是无法改变的." 它是一个只能被改变一次的变量.你可能出于两种理由而需要组织改变:设计和效率.  由于这两个原因相差甚远. 所以final有可能被误用.

我们讨论以下三个可能用到final的情况: 数据 . 方法 . 类

• Final数据

许多编程语言都有某种方法,来向编译器告知某一块数据是恒定不变的. 由于以下;两种原因,数据的恒定不变是很有用的:

          1 . 它可以是一个永不改变的"编译器常量(Compile-time constant)"
          2 . 它可以是一个在运行期被初始化的值,而你不希望它被改变.

   在编译期常量的情况下,编译器可以将常量值带入任何可能用到它的计算式中.就是说,可以在编译期执行计算式,减轻了一些运行期的负担.在Java中,这些常量必须是原始的并且以关键字final表示. 在对这个变量进行定义的时候,必须对其进行赋值(如果不赋值的话,系统会自动赋值,这样就无改变它的值了!).        

   一个即使static有事final的域(Data member)只占有一份不能改变的储存空间.
  
   当对对象引用而不是原始类型(基本数据类型)运用final时,其含义会有一点令人迷惑. 对于原始类型,final使数值恒定不变,而对于对象引用,final使引用恒定不变. 一旦引用被初始化指向一个对象,就无法对他进行改变以指向另一个对象. 然而,对象其自身却是可以修改的,Java并未提供任何使对象恒定不变的途径.(当然,你可以自己编写这样的类以实现此效果) 这一限制同样适用数组,它也是对象.

给大家个例子看看:

1. // FinalData.java
2. import java.util.*;
3. 
   
4. class Value {
5.     int i;       //包访问权限
6.     public Value(int i) { this.i = i;}
7. }
8. 
   
9. public class FinalData {
10.     private static Random rand = new Random(23);
11.     private String id;
12.   public FinalData(String id) { this.id = id;}
13.   private final int VAL_ONE = 9;
14.   private static final int VAL_TWO = 99;
15.   public static final int VAL_THREE = 39;
16.   private final int i4 = rand.nextInt(23);
17.   static final int i5 = rand.nextInt(23);
18.   
19.   private Value v1 = new Value(11);
20.   private final Value v2 = new Value(22);
21.   private static final Value v3 = new Value(33);
22.   //数组
23.   private final int[] a = {1,2,3,4,5,6,7,8,9};
24.   public String toString() {          //重写了toString方法以便输出信息
25.     return id + ": " + "i4 = " + i4 + ", i5 = " + i5;
26.   }
27.   public static void main(String[] args) {
28.     FinalData fd1 = new FinalData("fd1");
29.     //! fd1.VAL_ONE++;   //错误:VAL_ONE是final的,不能改变
30.     fd1.v2.i++;          //这个i是属于fd1对象的,这里改变的是对象本
31.                              //身,fianl指不能改变引用
32.     fd1.v1 = new Value(9); //没问题.因为v1不是final的,所以可以是它
33.                                //指向另外的对象
34.     for(int i=0;i<fd1.a.length; i++)
35.         fd1.a[i]++;         //没问题.同v2,这里改变的是数组对象
36.                                    //本身,final是限制更改指向关系
37.     //! fd1.v2 = new Value(0); //错误: v2引用是final的,不能指向另
38.                                    //外的对象
39.     //! fd1.v3 = new Value(1); //错误: 同上.即使它是static的
40.     //!fd1.a = new int[3];     //错误: 同上
41.     System.out.println(fd1);
42.     FinalData fd2 = new FinalData("fd2");
43.     System.out.println(fd1);
44.     System.out.println(fd2);
45.   }
46. }

   由于VAL_ONE和VAL_TWO是带有编译期数值的final原始类型,所以他们二者均可以用作编译期常量,并且没有重大区别. VAL_THREE是一种更加典型的对常量进行定义的方式:定义为public,则可以被用于包之外; 定义为static来强调只有一份; 定义为final来说明它是一个常量. 请注意,带有恒定初始值(即,编译期常量)的final static原始类型全部用大写字母命名,并且字与字之间用下划线隔开.  在编译期i5的值是无法得知的,因此为用大写字母表示.

   我们不能因为某数据是final的就认为再编译期可以知道它的值. 在运行期使用随机生成的数值来初始化i4和i5,就说明了这一点. 示例部分还展示了将final数值定于为static和非static的区别. 此区别只有在数值在运行期内初始化时才会显现,这是因为编译器对编译期数值一视同仁.(并且他们可能因优化而消失.) 当你运行程序是,就会看到这个区别.请注意,在fd1和fd2中,i4的值是唯一的,但i5的值是不可以通过创建第二个FinalData对象而加以改变的. 这是因为它是static,在装载是已被初始化.而不是每次创建对象时都被初始化.

   从v1到v3的变量说明了final引用的意义.正如你在main()中所看到的,不能因为v2是final的,就认为你无法改变它的值.由于它是一个引用,final仅仅意味着你无法将v2再次指向另一个新的对象. 你会看到,这对数据具有同样的意义,数组则是另一种引用.  看起来,使引用成为final没有使原始类型成为final用处大. 

---

   空白final 

Java允许生成空白final(Blank final),所谓空白final是指被声明为final担又给定初始值的数据成员. 无论什么情况,编译器都确保空白final在使用前必须被初始化. 但是,空白final在关键字final的使用上提供更大的灵活性,为此,一个类中的final数据成员就可以依对象而有所不同,却又保持其恒定不变的特性. 来看例子:

1. class Poppet {
2.     private int i;
3.     Poppet(int ii) {
4.         i = ii;
5.     }
6. }
8. public class BlankFinal {
9.     private final int i = 0;   //在定义处初始化
10.     private final int j;    //空final
11.     private static final int k;
12.     private final Poppet p;
13.     
14.     public BlankFinal() {
15.         j = 1;      //在构造器中初始化j
16.         p = new Poppet(1);  //在构造器中初始化j
17.     }
18.     
19.     public BlankFinal(int x) {
20.         j = x;
21.         p = new Poppet(x);
22.     }
23.     
24.     public static void main(String[] args) {
25.         new BlankFinal();
26.         new BlankFinal(47);
27.     }
28. }

此种使用final的方式,通过参数的不同调用不同的构造器,进而使同一个final j具有不同的值,使同一个final p指向不同的对象.并且同样达到了创建对象后,final的数据不能再改变的效果.



注意:final修饰的数据必须在数据成员的定义处或者是每个构造器中用表达式对final进行赋值.如果该成员同时是static的,那么必须在定义处就给予赋初值.(因为static的成员在类装载的时候就要进行初始化的,它们只有一份并且属于类所有而不属于对象,而非static的成员只有在运行时才初始化,所以可以不在定义处赋初值,而在每个构造器中进行,否则会被赋予默认值) 这正是final数据成员在使用前总是被初始化的原因所在.