Java中final關鍵字的原理和使用

這篇文章主要講解了“Java中final關鍵字的原理和使用”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java中final關鍵字的原理和使用”吧！

前言

final 關鍵字的字面意思是最終的，不可修改的。這似乎是一個看見名字就大概知道怎么用的語法，但你是否有深究過final在各個場景中的具體用法，注意事項，以及背后涉及的Java設計思想呢？

一. final 修飾變量

1. 基礎: final 修飾基本數據類型變量和引用數據類型變量

相信大家都具備基本的常識: 被 final 修飾的變量是不能夠被改變的。但是這里的”不能夠被改變”對于不同的數據類型是有不同的含義的。

當 final 修飾的是一個基本數據類型數據時，這個數據的值在初始化后將不能被改變；

當 final 修飾的是一個引用類型數據時，也就是修飾一個對象時，引用在初始化后將永遠指向一個內存地址，不可修改。但是該內存地址中保存的對象信息，是可以進行修改的。

上一段話可能比較抽象，希望下面的圖能有助于你理解，你會發現雖說有不同的含義，但本質還是一樣的。

首先是 final 修飾基本數據類型時的內存示意圖：

如上圖, 變量 a 在初始化后將永遠指向 003 這塊內存，而這塊內存在初始化后將永遠保存數值 100。

下面是 final 修飾引用數據類型的示意圖：

在上圖中，變量 p 指向了 0003 這塊內存，0003 內存中保存的是對象 p 的句柄(存放對象p數據的內存地址)，這個句柄值是不能被修改的，也就是變量 p 永遠指向 p 對象. 但是 p 對象的數據是可以修改的。

// 代碼示例public static void main(String[] args) { final Person p = new Person(20, "炭燒生蠔"); p.setAge(18); //可以修改p對象的數據 System.out.println(p.getAge()); //輸出18 Person pp = new Person(30, "蠔生燒炭"); p = pp; //這行代碼會報錯, 不能通過編譯, 因為p經final修飾永遠指向上面定義的p對象, 不能指向pp對象. }

不難看出 final 修飾變量的本質: final 修飾的變量會指向一塊固定的內存，這塊內存中的值不能改變。

引用類型變量所指向的對象之所以可以修改，是因為引用變量不是直接指向對象的數據，而是指向對象的引用。

所以被 final 修飾的引用類型變量將永遠指向一個固定的對象，不能被修改；對象的數據值可以被修改。

2. 進階：被 final 修飾的常量在編譯階段會被放入常量池中

final 是用于定義常量的，定義常量的好處是：不需要重復地創建相同的變量。

而常量池是 Java 的一項重要技術，由 final 修飾的變量會在編譯階段放入到調用類的常量池中。

請看下面這段演示代碼，這個示例是專門為了演示而設計的，希望能方便大家理解這個知識點。

public static void main(String[] args) { int n1 = 2019;   //普通變量 final int n2 = 2019; //final修飾的變量 String s = "20190522";  String s1 = n1 + "0522"; //拼接字符串"20190512" String s2 = n2 + "0522";  System.out.println(s == s1); //false System.out.println(s == s2); //true}

溫馨提示：整數 -127 - 128 是默認加載到常量池里的，也就是說如果涉及到 -127 - 128 的整數操作，默認在編譯期就能確定整數的。所以這里我故意選用數字2019 (大于128)，避免數字默認就存在常量池中。

上面的代碼運作過程是這樣的:

首先根據 final 修飾的常量會在編譯期放到常量池的原則，n2會在編譯期間放到常量池中。

然后 s 變量所對應的”20190522”字符串會放入到字符串常量池中，并對外提供一個引用返回給 s 變量。（下一篇文章會介紹字符串常量池）

這時候拼接字符串 s1，由于 n1 對應的數據沒有放入常量池中，所以 s1 暫時無法拼接，需要等程序加載運行時才能確定 s1 對應的值。

但在拼接 s2 的時候，由于 n2 已經存在于常量池，所以可以直接與”0522”拼接，拼接出的結果是”20190522”

這時系統會查看字符串常量池，發現已經存在字符串20190522，所以直接返回20190522的引用。

所以 s2 和 s 指向的是同一個引用，這個引用指向的是字符串常量池中的20190522。

而 n1 會在程序執行時，才有具體的指向。

當拼接 s1 的時候，會創建一個新的 String 類型對象，也就是說字符串常量池中的 20190522 會對外提供一個新的引用。

所以當 s1 與 s 用 “==” 判斷時, 由于對應的引用不同, 會返回 false。而 s2 和 s 指向同一個引用，返回true。

這個例子額外說明的是：由于被 final 修飾的常量會在編譯期進入常量池，如果有涉及到該常量的操作，很有可能在編譯期就已經完成。

3. 探索: 為什么局部/匿名內部類在使用外部局部變量時，只能使用被 final 修飾的變量?

提示: 在JDK1.8以后，通過內部類訪問外部局部變量時，無需顯式把外部局部變量聲明為final。不是說不需要聲明為final了，而是這件事情系統在編譯期間幫我們做了。 但是我們還是有必要了解為什么要用 final 修飾外部局部變量。

public class Outter { public static void main(String[] args) {  final int a = 10;  new Thread(){   @Override   public void run() {    System.out.println(a);   }  }.start(); }}

在上面這段代碼, 如果沒有給外部局部變量 a 加上 final 關鍵字，是無法通過編譯的。可以試著想想：當 main 方法已經執行完后，main 方法的棧幀將會彈出，如果此時 Thread 對象的生命周期還沒有結束，還沒有執行打印語句的話，將無法訪問到外部的 a 變量。

那么為什么加上 final 關鍵字就能正常編譯呢?

我們通過查看反編譯代碼看看內部類是怎樣調用外部成員變量的。

我們可以先通過 javac 編譯得到 .class文件(用IDE編譯也可以)，然后在命令行輸入javap -c .class文件的絕對路徑，就能查看 .class 文件的反編譯代碼。

以上的 Outter 類經過編譯產生兩個 .class 文件，分別是Outter.class 和 Outter$1.class

也就是說內部類會單獨編譯成一個.class文件。

下面給出Outter$1.class的反編譯代碼。

Compiled from "Outter.java"final class forTest.Outter$1 extends java.lang.Thread { forTest.Outter$1(); Code:  0: aload_0  1: invokespecial #1     // Method java/lang/Thread."<init>":()V  4: return public void run(); Code:  0: getstatic  #2     // Field java/lang/System.out:Ljava/io/PrintStream;  3: bipush  10  5: invokevirtual #3     // Method java/io/PrintStream.println:(I)V  8: return}

定位到run()方法反編譯代碼中的第3行:

3: bipush 10

我們看到 a 的值在內部類的run()方法執行過程中是以壓棧的形式存儲到本地變量表中的，

也就是說在內部類打印變量 a 的值時，這個變量 a 不是外部的局部變量 a，因為如果是外部局部變量的話，應該會使用load指令加載變量的值。

也就是說系統以拷貝的形式把外部局部變量 a 復制了一個副本到內部類中，內部類有一個變量指向外部變量a所指向的值。

但研究到這里好像和 final 的關系還不是很大，不加 final 似乎也可以拷貝一份變量副本，只不過不能在編譯期知道變量的值罷了。這時該思考一個新問題了：

現在我們知道內部類的變量 a 和外部局部變量 a 是兩個完全不同的變量，

那么如果在執行 run() 方法的過程中, 內部類中修改了 a 變量所指向的值，就會產生數據不一致問題。

正因為我們的原意是內部類和外部類訪問的是同一個a變量，所以當在內部類中使用外部局部變量的時候應該用 final 修飾局部變量，這樣局部變量a的值就永遠不會改變，也避免了數據不一致問題的發生。

二. final修飾方法使用 final 修飾方法有兩個作用，首要作用是鎖定方法，不讓任何繼承類對其進行修改。

另外一個作用是在編譯器對方法進行內聯，提升效率。 但是現在已經很少這么使用了，近代的Java版本已經把這部分的優化處理得很好了。

但是為了滿足求知欲還是了解一下什么是方法內斂：

方法內斂: 當調用一個方法時，系統需要進行保存現場信息，建立棧幀，恢復線程等操作，這些操作都是相對比較耗時的。

如果使用 final 修飾一個了一個方法 a，在其他調用方法 a 的類進行編譯時，方法 a 的代碼會直接嵌入到調用 a 的代碼塊中。

//原代碼public static void test(){  String s1 = "包夾方法a";  a();  String s2 = "包夾方法a";}public static final void a(){  System.out.println("我是方法a中的代碼");  System.out.println("我是方法a中的代碼");}//經過編譯后public static void test(){  String s1 = "包夾方法a";  System.out.println("我是方法a中的代碼");  System.out.println("我是方法a中的代碼");  String s2 = "包夾方法a";}

在方法非常龐大的時候，這樣的內嵌手段是幾乎看不到任何性能上的提升的，在最近的 Java 版本中，不需要使用 final 方法進行這些優化了。

三. final 修飾類

使用 final 修飾類的目的簡單明確：表明這個類不能被繼承。

當程序中有永遠不會被繼承的類時，可以使用 final 關鍵字修飾。

被 final 修飾的類所有成員方法都將被隱式修飾為 final 方法。

感謝各位的閱讀，以上就是“Java中final關鍵字的原理和使用”的內容了，經過本文的學習后，相信大家對Java中final關鍵字的原理和使用這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！