测试代码如下：

1. import java.util.*;
   
2. class Person
   
3. {
   
4.         private int age;
   
5.         public Person(){}
   
6.         public Person(int age)
   
7.         {
   
8.                 this.age = age;
   
9.         }
   
10.         public void setAge(int age)
    
11.         {
    
12.                 this.age = age;
    
13.         }
    
14.         public int getAge()
    
15.         {
    
16.                 return age;
    
17.         }
    
18. }
    
19. class  TestFinal
    
20. {
    
21.         public static void main(String[] args)
    
22.         {
    
23.                 //1，定义一个基本类型
    
24.                 final int num = 20;
    
25.                 //num = 30;          //无法为最终变量num指定值
    
26.                 System.out.println("num = "+num);
    
27.                
    
28.                 //2，定义一个数组
    
29.                 final int[] arr = {5,6,12,9};
    
30.                 System.out.println("原数组："+Arrays.toString(arr));
    
31.                 Arrays.sort(arr);
    
32.                 System.out.println("排序后："+Arrays.toString(arr));
    
33.                 arr[2] = -8;
    
34.                 System.out.println("修改后："+Arrays.toString(arr));
    
35.                
    
36.                 //3，第一个类类型
    
37.                 final Person p = new Person(10);
    
38.                 p.setAge(15);
    
39.                 System.out.println("修改后的age="+p.getAge());
    
40.         }
    
41. }

复制代码

运行结果如下：

问题：我知道对于final修饰成员变量而言，一旦有了初始值后，就不能被重新赋值了，以上第1段代码示例能够解释，
          但是，如第2,3段代码所示，我声明了数组和类这2个引用类型，并且也使用final修饰，之后对数组的值和类的实例属性都进行了修改，
          为什么修改成功了？不是说final修饰的变量时最终变量，代码运行时再不能重新赋值吗？请知道的亲们，赐教！

Final修饰的基本类型变量时，不能对基本变量重新赋值，因此基本类型变量不能被改变。但对引用类型而言，它保存的仅仅是一个引用，final只保证这个引用的引用地址不会被改变，即一直引用同一对象，但这个对象完全可以改变。所以final修饰的引用变量无法在编译时获取值，而是在运行时获取值。

1. public static void main(String[] args) {
   
2.                 // 1，定义一个基本类型
   
3. 
   
4.                 final int num = 20;
   
5.                 // num = 30; //无法为最终变量num指定值
   
6.                 System.out.println("num = " + num);
   
7. 
   
8.                 // 2，定义一个数组
   
9.                 final int[] arr = { 5, 6, 12, 9 };
   
10.                 System.out.println("原数组：" + Arrays.toString(arr));
    
11.                 Arrays.sort(arr);
    
12.                 System.out.println("排序后：" + Arrays.toString(arr));
    
13.                 arr[2] = -8;
    
14.                 System.out.println("修改后：" + Arrays.toString(arr));
    
15.                 /*
    
16.                  * 解释:这你定义的是一个数组，数组属于引用类型，对于引用类型的变量，它保存的是仅仅是一个引用，final只保证这引用的地址不会
    
17.                  * 改变，即一直引用一个对象，但这个对象是可以改变的。
    
18.                  * 你可以在代码再添加一句代码，就明白了
    
19.                  * 代码如：arr=null;这句代码的意思是从新给引用变量赋值。
    
20.                  * */
    
21.                
    
22.                 // 3，第一个类类型
    
23. 
    
24.                 final Person p = new Person(10);
    
25. 
    
26.                 p.setAge(15);
    
27. 
    
28.                 System.out.println("修改后的age=" + p.getAge());
    
29.                
    
30.                 /*
    
31.                  * 解释：同理Person也是一个对象，属于引用类型。p变量仅仅是一个引用，它保存的是堆内存中Person对象的地址，
    
32.                  * p.setAge(15);并没有改变引用变量p的值 ，只是改变了堆内存中的Person对象的值。
    
33.                  * 同意，你在结尾处添加p=null; 这是就编译不过了，提示你final修饰的变量不可以改变。
    
34.                  */
    
35. 
    
36.         }

复制代码

希望对你有所帮助！

为了把问题搞清楚，我还是画了个简单的内存图，从内存图中可以看出，arr所引用的对象始终没有发生变化，
这就是final修饰的作用，下面那个也是同样的道理。

袁见 发表于 2013-3-8 20:53
希望对你有所帮助！

谢谢你，对我很有帮助！