黑马程序员技术交流社区

标题: final修饰基本类型和引用类型变量有什么区别，请赐教？ [打印本页]
作者: HM李超    时间: 2013-3-8 19:33
标题: final修饰基本类型和引用类型变量有什么区别，请赐教？
测试代码如下：
  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修饰的变量时最终变量，代码运行时再不能重新赋值吗？请知道的亲们，赐教！


作者: 夏晓彤    时间: 2013-3-8 19:47
Final修饰的基本类型变量时，不能对基本变量重新赋值，因此基本类型变量不能被改变。但对引用类型而言，它保存的仅仅是一个引用，final只保证这个引用的引用地址不会被改变，即一直引用同一对象，但这个对象完全可以改变。所以final修饰的引用变量无法在编译时获取值，而是在运行时获取值。
作者: scott0610    时间: 2013-3-8 20:53
  1. public static void main(String[] args) {
  2.                 // 1，定义一个基本类型

  4.                 final int num = 20;
  5.                 // num = 30; //无法为最终变量num指定值
  6.                 System.out.println("num = " + num);

  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，第一个类类型

  24.                 final Person p = new Person(10);

  26.                 p.setAge(15);

  28.                 System.out.println("修改后的age=" + p.getAge());
  29.                
  30.                 /*
  31.                  * 解释：同理Person也是一个对象，属于引用类型。p变量仅仅是一个引用，它保存的是堆内存中Person对象的地址，
  32.                  * p.setAge(15);并没有改变引用变量p的值 ，只是改变了堆内存中的Person对象的值。
  33.                  * 同意，你在结尾处添加p=null; 这是就编译不过了，提示你final修饰的变量不可以改变。
  34.                  */

  36.         }
复制代码
希望对你有所帮助！
作者: 杨剑    时间: 2013-3-8 21:35
为了把问题搞清楚，我还是画了个简单的内存图，从内存图中可以看出，arr所引用的对象始终没有发生变化，
这就是final修饰的作用，下面那个也是同样的道理。

详细过程2.png (36.55 KB, 下载次数: 57)

详细过程2.png
作者: HM李超    时间: 2013-3-8 22:28
袁见 发表于 2013-3-8 20:53
希望对你有所帮助！

谢谢你，对我很有帮助！



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2