加个Final就能防止被修改？是我太naive了

本文转载自微信公众号「JerryCodes」，作者KyleJerry 。转载本文请联系JerryCodes公众号。

创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：网站设计制作、做网站、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的和县网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

  • 什么是不变性
  • final 和不可变的关系
  • 总结

什么是不变性

要想回答上面的问题，我们首先得知道什么是不变性(Immutable)。如果对象在被创建之后，其状态就不能修改了，那么它就具备“不变性”。

我们举个例子，比如下面这个 Person 类：

 
 
 
    
  
  
  
  1. public class Person { 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.     final int id = 1; 
    4. 
  
  
  
  4.     final int age = 18; 
    5. 
  
  
  
  5. } 
    6.

如果我们创建一个 person 对象，那么里面的属性会有两个，即 id 和 age，并且由于它们都是被 final 修饰的，所以一旦这个 person 对象被创建好，那么它里面所有的属性，即 id 和 age 就都是不能变的。我们如果想改变其中属性的值就会报错，代码如下所示：

 
 
 
    
  
  
  
  1. public class Person { 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.     final int id = 1; 
    4. 
  
  
  
  4.     final int age = 18; 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.     public static void main(String[] args) { 
    7. 
  
  
  
  7.         Person person = new Person(); 
    8. 
  
  
  
  8. //        person.age=5;//编译错误，无法修改 final 变量的值 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10. } 
    11.

比如我们尝试去改变这个 person 对象，例如将 age 改成 5，则会编译通不过，所以像这样的 person 对象就具备不变性，也就意味着它的状态是不能改变的。

final 修饰对象时，只是引用不可变!

这里有个非常重要的注意点，那就是当我们用 final 去修饰一个指向对象类型(而不是指向 8 种基本数据类型，例如 int 等)的变量时候，那么 final 起到的作用只是保证这个变量的引用不可变，而对象本身的内容依然是可以变化的。下面我们对此展开讲解。

被 final 修饰的变量意味着一旦被赋值就不能修改，也就是只能被赋值一次，如果我们尝试对已经被 final 修饰过的变量再次赋值的话，则会报编译错误。我们用下面的代码来说明：

 
 
 
    
  
  
  
  1. /** 
    2. 
  
  
  
  2.  * 描述：     final变量一旦被赋值就不能被修改 
    3. 
  
  
  
  3.  */ 
    4. 
  
  
  
  4. public class FinalVarCantChange { 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.     private final int finalVar = 0; 
    7. 
  
  
  
  7.     private final Random random = new Random(); 
    8. 
  
  
  
  8.     private final int array[] = {1,2,3}; 
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.     public static void main(String[] args) { 
    11. 
  
  
  
  11.         FinalVarCantChange finalVarCantChange = new FinalVarCantChange(); 
    12. 
  
  
  
  12. //        finalVarCantChange.finalVar=9;     //编译错误，不允许修改final的变量(基本类型) 
    13. 
  
  
  
  13. //        finalVarCantChange.random=null;    //编译错误，不允许修改final的变量(对象) 
    14. 
  
  
  
  14. //        finalVarCantChange.array = new int[5];//编译错误，不允许修改final的变量（数组） 
    15. 
  
  
  
  15.     } 
    16. 
  
  
  
  16. } 
    17.

我们首先在这里分别创建了一个 int 类型的变量、一个 Random 类型的变量，还有一个是数组，它们都是被 final 修饰的;然后尝试对它们进行修改，比如把 int 变量的值改成 9，或者把 random 变量置为 null，或者给数组重新指定一个内容，这些代码都无法通过编译。

这就证明了“被 final 修饰的变量意味着一旦被赋值就不能修改”，而这个规则对于基本类型的变量是没有歧义的，但是对于对象类型而言，final 其实只是保证这个变量的引用不可变，而对象本身依然是可以变化的。这一点同样适用于数组，因为在 Java 中数组也是对象。那我们就来举个例子，看一看以下 Java 程序的输出：

 
 
 
    
  
  
  
  1. class Test { 
    2. 
  
  
  
  2.     public static void main(String args[]) { 
    3. 
  
  
  
  3.        final int arr[] = {1, 2, 3, 4, 5};  //  注意，数组 arr 是 final 的 
    4. 
  
  
  
  4.        for (int i = 0; i < arr.length; i++) { 
    5. 
  
  
  
  5.            arr[i] = arr[i]*10; 
    6. 
  
  
  
  6.            System.out.println(arr[i]); 
    7. 
  
  
  
  7.        } 
    8. 
  
  
  
  8.     } 
    9. 
  
  
  
  9. } 
    10.

首先来猜测一下，假设不看下面的输出结果，只看这段代码，你猜它打印出什么样的结果?

这段代码中有个 Test 类，而且这个类只有一个 main 方法，方法里面有一个 final 修饰的 arr 数组。注意，数组是对象的一种，现在数组是被 final 修饰的，所以它的意思是一旦被赋值之后，变量的引用不能修改。

但是我们现在想证明的是，数组对象里面的内容可以修改，所以接下来我们就用 for 循环把它里面的内容都乘以 10，最后打印出来结果如下：

 
 
 
    
  
  
  
  1. 10  
    2. 
  
  
  
  2. 20  
    3. 
  
  
  
  3. 30  
    4. 
  
  
  
  4. 40  
    5. 
  
  
  
  5. 50 
    6.

可以看到，它打印出来的是 10 20 30 40 50，而不是最开始的 1 2 3 4 5，这就证明了，虽然数组 arr 被 final 修饰了，它的引用不能被修改，但是里面的内容依然是可以被修改的。

同样，对于非数组的对象而言也是如此，我们来看下面的例子：

 
 
 
    
  
  
  
  1. class Test {  
    2. 
  
  
  
  2.     int p = 20;  
    3. 
  
  
  
  3.     public static void main(String args[]){  
    4. 
  
  
  
  4.        final Test t = new Test(); 
    5. 
  
  
  
  5.        t.p = 30;  
    6. 
  
  
  
  6.        System.out.println(t.p); 
    7. 
  
  
  
  7.     } 
    8. 
  
  
  
  8. } 
    9.

这个 Test 类中有一个 int 类型的 p 属性，我们在 main 函数中新建了 Test 的实例 t 之后，把它用 final 修饰，然后去尝试改它里面成员变量 p 的值，并打印出结果，程序会打印出“30”。一开始 p 的值是 20，但是最后修改完毕变成了 30，说明这次修改是成功的。

以上我们就得出了一个结论，final 修饰一个指向对象的变量的时候，对象本身的内容依然是可以变化的。

final 和不可变的关系

这里就引申出一个问题，那就是 final 和不变性究竟是什么关系?

那我们就来具体对比一下 final 和不变性。关键字 final 可以确保变量的引用保持不变，但是不变性意味着对象一旦创建完毕就不能改变其状态，它强调的是对象内容本身，而不是引用，所以 final 和不变性这两者是很不一样的。

对于一个类的对象而言，你必须要保证它创建之后所有内部状态(包括它的成员变量的内部属性等)永远不变，才是具有不变性的，这就要求所有成员变量的状态都不允许发生变化。

有一种说法就认为：“要想保证对象具有不变性的最简单的办法，就是把类中所有属性都声明为 final”，这条规则是不完全正确的，它通常只适用于类的所有属性都是基本类型的情况，比如前面的例子：

 
 
 
    
  
  
  
  1. public class Person { 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.     final int id = 1; 
    4. 
  
  
  
  4.     final int age = 18; 
    5. 
  
  
  
  5. } 
    6.

Person 类里面有 final int id 和 final int age 两个属性，都是基本类型的，且都加了 final，所以 Person 类的对象确实是具备不变性的。

但是如果一个类里面有一个 final 修饰的成员变量，并且这个成员变量不是基本类型，而是对象类型，那么情况就不一样了。有了前面基础之后，我们知道，对于对象类型的属性而言，我们如果给它加了 final，它内部的成员变量还是可以变化的，因为 final 只能保证其引用不变，不能保证其内容不变。所以这个时候若一旦某个对象类型的内容发生了变化，就意味着这整个类都不具备不变性了。

所以我们就得出了这个结论：不变性并不意味着，简单地使用 final 修饰所有类的属性，这个类的对象就具备不变性了。

那就会有一个很大的疑问，假设我的类里面有一个对象类型的成员变量，那要怎样做才能保证整个对象是不可变的呢?

我们来举个例子，即一个包含对象类型的成员变量的类的对象，具备不可变性的例子。

代码如下：

 
 
 
    
  
  
  
  1. public class ImmutableDemo { 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.     private final Set lessons = new HashSet<>(); 
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5.     public ImmutableDemo() { 
    6. 
  
  
  
  6.         lessons.add("第01讲：为何说只有 1 种实现线程的方法？"); 
    7. 
  
  
  
  7.         lessons.add("第02讲：如何正确停止线程？为什么 volatile 标记位的停止方法是错误的？"); 
    8. 
  
  
  
  8.         lessons.add("第03讲：线程是如何在 6 种状态之间转换的？"); 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11.     public boolean isLesson(String name) { 
    12. 
  
  
  
  12.         return lessons.contains(name); 
    13. 
  
  
  
  13.     } 
    14. 
  
  
  
  14. } 
    15.

在这个类中有一个 final 修饰的、且也是 private 修饰的的一个 Set 对象，叫作 lessons，它是个 HashSet;然后我们在构造函数中往这个 HashSet 里面加了三个值，分别是第 01、02、03 讲的题目;类中还有一个方法，即 isLesson，去判断传入的参数是不是属于本课前 3 讲的标题，isLesson 方法就是利用 lessons.contains 方法去判断的，如果包含就返回 true，否则返回 false。这个类的内容就是这些了，没有其他额外的代码了。

在这种情况下，尽管 lessons 是 Set 类型的，尽管它是一个对象，但是对于 ImmutableDemo 类的对象而言，就是具备不变性的。因为 lessons 对象是 final 且 private 的，所以引用不会变，且外部也无法访问它，而且 ImmutableDemo 类也没有任何方法可以去修改 lessons 里包含的内容，只是在构造函数中对 lessons 添加了初始值，所以 ImmutableDemo 对象一旦创建完成，也就是一旦执行完构造方法，后面就再没有任何机会可以修改 lessons 里面的数据了。

而对于 ImmutableDemo 类而言，它就只有这么一个成员变量，而这个成员变量一旦构造完毕之后又不能变，所以就使得这个 ImmutableDemo 类的对象是具备不变性的，这就是一个很好的“包含对象类型的成员变量的类的对象，具备不可变性”的例子。

总结

我们首先介绍了什么是不变性，然后介绍了用 final 修饰一个对象类型的变量的时候，只能保证它的引用不变，但是对象内容自身依然是可以变的。

仅仅把所有的成员变量都用 final 修饰并不能代表类的对象就是具备不变性的。

当前文章：加个Final就能防止被修改？是我太naive了
分享路径：http://www.36103.cn/qtweb/news41/21291.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制网站知识

同城分类信息

品牌网站建设公司　　 　成都法律咨询　　 　成都电信光华数据中心　　 　SSL证书　　 　云主机　　 　香港云虚拟主机　　 　光华村机房　　 　商城网站建设　　 　棕树数据中心　　 　app开发公司　　 　网站维护　　 　德阳机房托管　　 　广安网站建设　　 　定制网站　　 　混凝土密封固化剂　　 　seo关键词优化　　 　成都工装公司　　 　成都云服务器　　 　成都广告制作　　 　成都名片印刷厂