前言

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

一. final 修飾變量

1. 基礎: final 修飾基本數(shù)據(jù)類型變量和引用數(shù)據(jù)類型變量

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

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

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

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

首先是 final 修飾基本數(shù)據(jù)類型時的內(nèi)存示意圖：

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

下面是 final 修飾引用數(shù)據(jù)類型的示意圖：

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

// 代碼示例
public static void main(String[] args) {
 final Person p = new Person(20, "炭燒生蠔");
 p.setAge(18); //可以修改p對象的數(shù)據(jù)
 System.out.println(p.getAge()); //輸出18

 Person pp = new Person(30, "蠔生燒炭");
 p = pp; //這行代碼會報錯, 不能通過編譯, 因為p經(jīng)final修飾永遠指向上面定義的p對象, 不能指向pp對象. 
}

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

引用類型變量所指向的對象之所以可以修改，是因為引用變量不是直接指向?qū)ο蟮臄?shù)據(jù)，而是指向?qū)ο蟮囊谩?/p>

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

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

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

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

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

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
}

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

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

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

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

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

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

這時系統(tǒng)會查看字符串常量池，發(fā)現(xiàn)已經(jīng)存在字符串20190522，所以直接返回20190522的引用。

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

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

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

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

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

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

提示: 在JDK1.8以后，通過內(nèi)部類訪問外部局部變量時，無需顯式把外部局部變量聲明為final。不是說不需要聲明為final了，而是這件事情系統(tǒng)在編譯期間幫我們做了。 但是我們還是有必要了解為什么要用 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 方法已經(jīng)執(zhí)行完后，main 方法的棧幀將會彈出，如果此時 Thread 對象的生命周期還沒有結束，還沒有執(zhí)行打印語句的話，將無法訪問到外部的 a 變量。

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

我們通過查看反編譯代碼看看內(nèi)部類是怎樣調(diào)用外部成員變量的。

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

以上的 Outter 類經(jīng)過編譯產(chǎn)生兩個 .class 文件，分別是Outter.class 和 Outter$1.class

也就是說內(nèi)部類會單獨編譯成一個.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 的值在內(nèi)部類的run()方法執(zhí)行過程中是以壓棧的形式存儲到本地變量表中的，

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

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

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

現(xiàn)在我們知道內(nèi)部類的變量 a 和外部局部變量 a 是兩個完全不同的變量，

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

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

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

另外一個作用是在編譯器對方法進行內(nèi)聯(lián)，提升效率。 但是現(xiàn)在已經(jīng)很少這么使用了，近代的Java版本已經(jīng)把這部分的優(yōu)化處理得很好了。

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

方法內(nèi)斂: 當調(diào)用一個方法時，系統(tǒng)需要進行保存現(xiàn)場信息，建立棧幀，恢復線程等操作，這些操作都是相對比較耗時的。

如果使用 final 修飾一個了一個方法 a，在其他調(diào)用方法 a 的類進行編譯時，方法 a 的代碼會直接嵌入到調(diào)用 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中的代碼");
}

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

在方法非常龐大的時候，這樣的內(nèi)嵌手段是幾乎看不到任何性能上的提升的，在最近的 Java 版本中，不需要使用 final 方法進行這些優(yōu)化了。—《Java編程思想》

三. final 修飾類

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

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

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

總結

以上就是這篇文章的全部內(nèi)容了，希望本文的內(nèi)容對大家的學習或者工作具有一定的參考學習價值，謝謝大家對腳本之家的支持。

最新評論