• 什么是不變性
• final 和不可變的關系
• 總結

什么是不變性

要想回答上面的問題，我們首先得知道什么是不變性(Immutable)。如果對象在被創建之后，其狀態就不能修改了，那么它就具備“不變性”。

我們舉個例子，比如下面這個 Person 類：

public class Person { 
 
    final int id = 1; 
    final int age = 18; 
} 

如果我們創建一個 person 對象，那么里面的屬性會有兩個，即 id 和 age，并且由于它們都是被 final 修飾的，所以一旦這個 person 對象被創建好，那么它里面所有的屬性，即 id 和 age 就都是不能變的。我們如果想改變其中屬性的值就會報錯，代碼如下所示：

public class Person { 
 
    final int id = 1; 
    final int age = 18; 
 
    public static void main(String[] args) { 
        Person person = new Person(); 
//        person.age=5;//編譯錯誤，無法修改 final 變量的值 
    } 
} 

比如我們嘗試去改變這個 person 對象，例如將 age 改成 5，則會編譯通不過，所以像這樣的 person 對象就具備不變性，也就意味著它的狀態是不能改變的。

final 修飾對象時，只是引用不可變!

這里有個非常重要的注意點，那就是當我們用 final 去修飾一個指向對象類型(而不是指向 8 種基本數據類型，例如 int 等)的變量時候，那么 final 起到的作用只是保證這個變量的引用不可變，而對象本身的內容依然是可以變化的。下面我們對此展開講解。

被 final 修飾的變量意味著一旦被賦值就不能修改，也就是只能被賦值一次，如果我們嘗試對已經被 final 修飾過的變量再次賦值的話，則會報編譯錯誤。我們用下面的代碼來說明：

/** 
 * 描述：     final變量一旦被賦值就不能被修改 
 */ 
public class FinalVarCantChange { 
 
    private final int finalVar = 0; 
    private final Random random = new Random(); 
    private final int array[] = {1,2,3}; 
 
    public static void main(String[] args) { 
        FinalVarCantChange finalVarCantChange = new FinalVarCantChange(); 
//        finalVarCantChange.finalVar=9;     //編譯錯誤，不允許修改final的變量(基本類型) 
//        finalVarCantChange.random=null;    //編譯錯誤，不允許修改final的變量(對象) 
//        finalVarCantChange.array = new int[5];//編譯錯誤，不允許修改final的變量（數組） 
    } 
} 

我們首先在這里分別創建了一個 int 類型的變量、一個 Random 類型的變量，還有一個是數組，它們都是被 final 修飾的;然后嘗試對它們進行修改，比如把 int 變量的值改成 9，或者把 random 變量置為 null，或者給數組重新指定一個內容，這些代碼都無法通過編譯。

這就證明了“被 final 修飾的變量意味著一旦被賦值就不能修改”，而這個規則對于基本類型的變量是沒有歧義的，但是對于對象類型而言，final 其實只是保證這個變量的引用不可變，而對象本身依然是可以變化的。這一點同樣適用于數組，因為在 Java 中數組也是對象。那我們就來舉個例子，看一看以下 Java 程序的輸出：

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

首先來猜測一下，假設不看下面的輸出結果，只看這段代碼，你猜它打印出什么樣的結果?

這段代碼中有個 Test 類，而且這個類只有一個 main 方法，方法里面有一個 final 修飾的 arr 數組。注意，數組是對象的一種，現在數組是被 final 修飾的，所以它的意思是一旦被賦值之后，變量的引用不能修改。

但是我們現在想證明的是，數組對象里面的內容可以修改，所以接下來我們就用 for 循環把它里面的內容都乘以 10，最后打印出來結果如下：

10  
20  
30  
40  
50 

可以看到，它打印出來的是 10 20 30 40 50，而不是最開始的 1 2 3 4 5，這就證明了，雖然數組 arr 被 final 修飾了，它的引用不能被修改，但是里面的內容依然是可以被修改的。

同樣，對于非數組的對象而言也是如此，我們來看下面的例子：

class Test {  
    int p = 20;  
    public static void main(String args[]){  
       final Test t = new Test(); 
       t.p = 30;  
       System.out.println(t.p); 
    } 
} 

這個 Test 類中有一個 int 類型的 p 屬性，我們在 main 函數中新建了 Test 的實例 t 之后，把它用 final 修飾，然后去嘗試改它里面成員變量 p 的值，并打印出結果，程序會打印出“30”。一開始 p 的值是 20，但是最后修改完畢變成了 30，說明這次修改是成功的。

以上我們就得出了一個結論，final 修飾一個指向對象的變量的時候，對象本身的內容依然是可以變化的。

final 和不可變的關系

這里就引申出一個問題，那就是 final 和不變性究竟是什么關系?

那我們就來具體對比一下 final 和不變性。關鍵字 final 可以確保變量的引用保持不變，但是不變性意味著對象一旦創建完畢就不能改變其狀態，它強調的是對象內容本身，而不是引用，所以 final 和不變性這兩者是很不一樣的。

對于一個類的對象而言，你必須要保證它創建之后所有內部狀態(包括它的成員變量的內部屬性等)永遠不變，才是具有不變性的，這就要求所有成員變量的狀態都不允許發生變化。

有一種說法就認為：“要想保證對象具有不變性的最簡單的辦法，就是把類中所有屬性都聲明為 final”，這條規則是不完全正確的，它通常只適用于類的所有屬性都是基本類型的情況，比如前面的例子：

public class Person { 
 
    final int id = 1; 
    final int age = 18; 
} 

Person 類里面有 final int id 和 final int age 兩個屬性，都是基本類型的，且都加了 final，所以 Person 類的對象確實是具備不變性的。

但是如果一個類里面有一個 final 修飾的成員變量，并且這個成員變量不是基本類型，而是對象類型，那么情況就不一樣了。有了前面基礎之后，我們知道，對于對象類型的屬性而言，我們如果給它加了 final，它內部的成員變量還是可以變化的，因為 final 只能保證其引用不變，不能保證其內容不變。所以這個時候若一旦某個對象類型的內容發生了變化，就意味著這整個類都不具備不變性了。

所以我們就得出了這個結論：不變性并不意味著，簡單地使用 final 修飾所有類的屬性，這個類的對象就具備不變性了。

那就會有一個很大的疑問，假設我的類里面有一個對象類型的成員變量，那要怎樣做才能保證整個對象是不可變的呢?

我們來舉個例子，即一個包含對象類型的成員變量的類的對象，具備不可變性的例子。

代碼如下：

public class ImmutableDemo { 
 
    private final Set<String> lessons = new HashSet<>(); 
 
    public ImmutableDemo() { 
        lessons.add("第01講：為何說只有 1 種實現線程的方法？"); 
        lessons.add("第02講：如何正確停止線程？為什么 volatile 標記位的停止方法是錯誤的？"); 
        lessons.add("第03講：線程是如何在 6 種狀態之間轉換的？"); 
    } 
 
    public boolean isLesson(String name) { 
        return lessons.contains(name); 
    } 
} 

在這個類中有一個 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 修飾并不能代表類的對象就是具備不變性的。