天天看點
傳回

java final關鍵字_夯實Java基礎系列4：一文了解final關鍵字的特性、使用方法，以及實作原理...

java final關鍵字_夯實Java基礎系列4：一文了解final關鍵字的特性、使用方法，以及實作原理...

目錄

  • final使用
    • final變量
    • final修飾基本資料類型變量和引用
    • final類
    • final關鍵字的知識點
  • final關鍵字的最佳實踐
    • final的用法
    • 關于空白final
    • final記憶體配置設定
    • 使用final修飾方法會提高速度和效率嗎
    • 使用final修飾變量會讓變量的值不能被改變嗎；
    • 如何保證數組内部不被修改
    • final方法的三條規則
  • final 和 jvm的關系
    • 寫 final 域的重排序規則
    • 讀 final 域的重排序規則
    • 如果 final 域是引用類型
  • 參考文章
  • 微信公衆号
    • Java技術江湖
    • 個人公衆号：黃小斜

本系列文章将整理到我在GitHub上的《Java面試指南》倉庫，更多精彩内容請到我的倉庫裡檢視

https:// github.com/h2pl/Java-Tu torial

喜歡的話麻煩點下Star哈

文章首發于我的個人部落格：

www.how2playlife.com

本文是微信公衆号【Java技術江湖】的《夯實Java基礎系列博文》其中一篇，本文部分内容來源于網絡，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格内容，引用其中了一些比較好的部落格文章，如有侵權，請聯系作者。 該系列博文會告訴你如何從入門到進階，一步步地學習Java基礎知識，并上手進行實戰，接着了解每個Java知識點背後的實作原理，更完整地了解整個Java技術體系，形成自己的知識架構。為了更好地總結和檢驗你的學習成果，本系列文章也會提供每個知識點對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公衆号【Java技術江湖】聯系作者，歡迎你參與本系列博文的創作和修訂。

<!-- more --> final關鍵字在java中使用非常廣泛，可以申明成員變量、方法、類、本地變量。一旦将引用聲明為final，将無法再改變這個引用。final關鍵字還能保證記憶體同步，本部落格将會從final關鍵字的特性到從java記憶體層面保證同步講解。這個内容在面試中也有可能會出現。

final使用

final變量

final變量有成員變量或者是本地變量(方法内的局部變量)，在類成員中final經常和static一起使用，作為類常量使用。

其中類常量必須在聲明時初始化，final成員常量可以在構造函數初始化。 
public class Main {
    public static final int i; //報錯，必須初始化 因為常量在常量池中就存在了，調用時不需要類的初始化，是以必須在聲明時初始化
    public static final int j;
    Main() {
        i = 2;
        j = 3;
    }
}
​

就如上所說的，對于類常量，JVM會緩存在常量池中，在讀取該變量時不會加載這個類。

​
public class Main {
    public static final int i = 2;
    Main() {
        System.out.println("調用構造函數"); // 該方法不會調用
    }
    public static void main(String[] args) {
        System.out.println(Main.i);
    }
}
​

final修飾基本資料類型變量和引用 

@Test
public void final修飾基本類型變量和引用() {
    final int a = 1;
    final int[] b = {1};
    final int[] c = {1};
//  b = c;報錯
    b[0] = 1;
    final String aa = "a";
    final Fi f = new Fi();
    //aa = "b";報錯
    // f = null;//報錯
    f.a = 1;
}

final方法表示該方法不能被子類的方法重寫，将方法聲明為final，在編譯的時候就已經靜态綁定了，不需要在運作時動态綁定。final方法調用時使用的是invokespecial指令。

class PersonalLoan{
    public final String getName(){
        return"personal loan”;
    }
}
​
class CheapPersonalLoan extends PersonalLoan{
    @Override
    public final String getName(){
        return"cheap personal loan";//編譯錯誤，無法被重載
    }
​
    public String test() {
        return getName(); //可以調用，因為是public方法
    }
}
​

final類

final類不能被繼承，final類中的方法預設也會是final類型的，java中的String類和Integer類都是final類型的。

class Si{
    //一般情況下final修飾的變量一定要被初始化。
    //隻有下面這種情況例外，要求該變量必須在構造方法中被初始化。
    //并且不能有空參數的構造方法。
    //這樣就可以讓每個執行個體都有一個不同的變量，并且這個變量在每個執行個體中隻會被初始化一次
    //于是這個變量在單個執行個體裡就是常量了。
    final int s ;
    Si(int s) {
        this.s = s;
    }
}
class Bi {
    final int a = 1;
    final void go() {
        //final修飾方法無法被繼承
    }
}
class Ci extends Bi {
    final int a = 1;
//        void go() {
//            //final修飾方法無法被繼承
//        }
}
final char[]a = {'a'};
final int[]b = {1};
final class PersonalLoan{}
​
class CheapPersonalLoan extends PersonalLoan {  //編譯錯誤，無法被繼承 
}
​
@Test
public void final修飾類() {
    //引用沒有被final修飾，是以是可變的。
    //final隻修飾了Fi類型，即Fi執行個體化的對象在堆中記憶體位址是不可變的。
    //雖然記憶體位址不可變，但是可以對内部的資料做改變。
    Fi f = new Fi();
    f.a = 1;
    System.out.println(f);
    f.a = 2;
    System.out.println(f);
    //改變執行個體中的值并不改變記憶體位址。
​
    Fi ff = f;
    //讓引用指向新的Fi對象，原來的f對象由新的引用ff持有。
    //引用的指向改變也不會改變原來對象的位址
    f = new Fi();
    System.out.println(f);
    System.out.println(ff);
}

final關鍵字的知識點

  1. final成員變量必須在聲明的時候初始化或者在構造器中初始化，否則就會報編譯錯誤。final變量一旦被初始化後不能再次指派。
  2. 本地變量必須在聲明時指派。 因為沒有初始化的過程
  3. 在匿名類中所有變量都必須是final變量。
  4. final方法不能被重寫, final類不能被繼承
  5. 接口中聲明的所有變量本身是final的。類似于匿名類
  6. final和abstract這兩個關鍵字是反相關的，final類就不可能是abstract的。
  7. final方法在編譯階段綁定，稱為靜态綁定(static binding)。
  8. 将類、方法、變量聲明為final能夠提高性能，這樣JVM就有機會進行估計，然後優化。

final方法的好處:

  1. 提高了性能，JVM在常量池中會緩存final變量
  2. final變量在多線程中并發安全，無需額外的同步開銷
  3. final方法是靜态編譯的，提高了調用速度
  4. final類建立的對象是隻可讀的，在多線程可以安全共享

final關鍵字的最佳實踐

final的用法

1、final 對于常量來說，意味着值不能改變，例如 final int i=100。這個i的值永遠都是100。 但是對于變量來說又不一樣，隻是辨別這個引用不可被改變，例如 final File f=new File("c:test.txt");

那麼這個f一定是不能被改變的，如果f本身有方法修改其中的成員變量，例如是否可讀，是允許修改的。有個形象的比喻：一個女子定義了一個final的老公，這個老公的職業和收入都是允許改變的，隻是這個女人不會換老公而已。

關于空白final

final修飾的變量有三種：靜态變量、執行個體變量和局部變量，分别表示三種類型的常量。 　另外，final變量定義的時候，可以先聲明，而不給初值，這中變量也稱為final空白，無論什麼情況，編譯器都確定空白final在使用之前必須被初始化。 但是，final空白在final關鍵字final的使用上提供了更大的靈活性，為此，一個類中的final資料成員就可以實作依對象而有所不同，卻有保持其恒定不變的特征。

public class FinalTest { 
final int p; 
final int q=3; 
FinalTest(){ 
p=1; 
} 
FinalTest(int i){ 
p=i;//可以指派，相當于直接定義p 
q=i;//不能為一個final變量指派 
} 
}

final記憶體配置設定

剛提到了内嵌機制，現在詳細展開。 要知道調用一個函數除了函數本身的執行時間之外，還需要額外的時間去尋找這個函數（類内部有一個函數簽名和函數位址的映射表）。是以減少函數調用次數就等于降低了性能消耗。

final修飾的函數會被編譯器優化，優化的結果是減少了函數調用的次數。如何實作的，舉個例子給你看：

public class Test{ 
final void func(){System.out.println("g");}; 
public void main(String[] args){ 
for(int j=0;j<1000;j++)   
func(); 
}} 
經過編譯器優化之後，這個類變成了相當于這樣寫： 
public class Test{ 
final void func(){System.out.println("g");}; 
public void main(String[] args){ 
for(int j=0;j<1000;j++)  
{System.out.println("g");} 
}}

看出來差別了吧？編譯器直接将func的函數體内嵌到了調用函數的地方，這樣的結果是節省了1000次函數調用，當然編譯器處理成位元組碼，隻是我們可以想象成這樣，看個明白。

不過，當函數體太長的話，用final可能适得其反，因為經過編譯器内嵌之後代碼長度大大增加，于是就增加了jvm解釋位元組碼的時間。

在使用final修飾方法的時候，編譯器會将被final修飾過的方法插入到調用者代碼處，提高運作速度和效率，但被final修飾的方法體不能過大，編譯器可能會放棄内聯，但究竟多大的方法會放棄，我還沒有做測試來計算過。

下面這些内容是通過兩個疑問來繼續闡述的

使用final修飾方法會提高速度和效率嗎

見下面的測試代碼，我會執行五次：

public class Test   
{   
    public static void getJava()   
    {   
        String str1 = "Java ";   
        String str2 = "final ";   
        for (int i = 0; i < 10000; i++)   
        {   
            str1 += str2;   
        }   
    }   
    public static final void getJava_Final()   
    {   
        String str1 = "Java ";   
        String str2 = "final ";   
        for (int i = 0; i < 10000; i++)   
        {   
            str1 += str2;   
        }   
    }   
    public static void main(String[] args)   
    {   
        long start = System.currentTimeMillis();   
        getJava();   
        System.out.println("調用不帶final修飾的方法執行時間為:" + (System.currentTimeMillis() - start) + "毫秒時間");   
        start = System.currentTimeMillis();   
        String str1 = "Java ";   
        String str2 = "final ";   
        for (int i = 0; i < 10000; i++)   
        {   
            str1 += str2;   
        }   
        System.out.println("正常的執行時間為:" + (System.currentTimeMillis() - start) + "毫秒時間");   
        start = System.currentTimeMillis();   
        getJava_Final();   
        System.out.println("調用final修飾的方法執行時間為:" + (System.currentTimeMillis() - start) + "毫秒時間");   
    }   
}  

結果為： 
第一次： 
調用不帶final修飾的方法執行時間為:1732毫秒時間 
正常的執行時間為:1498毫秒時間 
調用final修飾的方法執行時間為:1593毫秒時間 
第二次： 
調用不帶final修飾的方法執行時間為:1217毫秒時間 
正常的執行時間為:1031毫秒時間 
調用final修飾的方法執行時間為:1124毫秒時間 
第三次： 
調用不帶final修飾的方法執行時間為:1154毫秒時間 
正常的執行時間為:1140毫秒時間 
調用final修飾的方法執行時間為:1202毫秒時間 
第四次： 
調用不帶final修飾的方法執行時間為:1139毫秒時間 
正常的執行時間為:999毫秒時間 
調用final修飾的方法執行時間為:1092毫秒時間 
第五次： 
調用不帶final修飾的方法執行時間為:1186毫秒時間 
正常的執行時間為:1030毫秒時間 
調用final修飾的方法執行時間為:1109毫秒時間 

由以上運作結果不難看出，執行最快的是“正常的執行”即代碼直接編寫，而使用final修飾的方法，不像有些書上或者文章上所說的那樣，速度與效率與“正常的執行”無異，而是位于第二位，最差的是調用不加final修飾的方法。

觀點：加了比不加好一點。

使用final修飾變量會讓變量的值不能被改變嗎；

見代碼：

public class Final   
{   
    public static void main(String[] args)   
    {   
        Color.color[3] = "white";   
        for (String color : Color.color)   
            System.out.print(color+" ");   
    }   
}   
  
class Color   
{   
    public static final String[] color = { "red", "blue", "yellow", "black" };   
}  

執行結果： 
red blue yellow white 
看！，黑色變成了白色。

​ 在使用findbugs插件時，就會提示public static String[] color = { "red", "blue", "yellow", "black" };這行代碼不安全，但加上final修飾，這行代碼仍然是不安全的，因為final沒有做到保證變量的值不會被修改！ ​ ​ 原因是：final關鍵字隻能保證變量本身不能被賦與新值，而不能保證變量的内部結構不被修改。例如在main方法有如下代碼Color.color = new String[]{""};就會報錯了。

如何保證數組内部不被修改 

那可能有的同學就會問了，加上final關鍵字不能保證數組不會被外部修改，那有什麼方法能夠保證呢？答案就是降低通路級别，把數組設為private。這樣的話，就解決了數組在外部被修改的不安全性，但也産生了另一個問題，那就是這個數組要被外部使用的。

解決這個問題見代碼：

import java.util.AbstractList;   
import java.util.List;   

public class Final   
{   
    public static void main(String[] args)   
    {   
        for (String color : Color.color)   
            System.out.print(color + " ");   
        Color.color.set(3, "white");   
    }   
}   
  
class Color   
{   
    private static String[] _color = { "red", "blue", "yellow", "black" };   
    public static List<String> color = new AbstractList<String>()   
    {   
        @Override  
        public String get(int index)   
        {   
            return _color[index];   
        }   
        @Override  
        public String set(int index, String value)   
        {   
            throw new RuntimeException("為了代碼安全,不能修改數組");   
        }   
        @Override  
        public int size()   
        {   
            return _color.length;   
        }   
    };  

}

這樣就OK了，既保證了代碼安全，又能讓數組中的元素被通路了。

final方法的三條規則

規則1：final修飾的方法不可以被重寫。

規則2：final修飾的方法僅僅是不能重寫，但它完全可以被重載。

規則3：父類中private final方法，子類可以重新定義，這種情況不是重寫。

代碼示例

規則1代碼

public class FinalMethodTest
{
	public final void test(){}
}
class Sub extends FinalMethodTest
{
	// 下面方法定義将出現編譯錯誤，不能重寫final方法
	public void test(){}
}

規則2代碼

public class Finaloverload {
	//final 修飾的方法隻是不能重寫，完全可以重載
	public final void test(){}
	public final void test(String arg){}
}

規則3代碼

public class PrivateFinalMethodTest
{
	private final void test(){}
}
class Sub extends PrivateFinalMethodTest
{
	// 下面方法定義将不會出現問題
	public void test(){}
}

final 和 jvm的關系

與前面介紹的鎖和 volatile 相比較，對 final 域的讀和寫更像是普通的變量通路。對于 final 域，編譯器和處理器要遵守兩個重排序規則：

  1. 在構造函數内對一個 final 域的寫入，與随後把這個被構造對象的引用指派給一個引用變量，這兩個操作之間不能重排序。
  2. 初次讀一個包含 final 域的對象的引用，與随後初次讀這個 final 域，這兩個操作之間不能重排序。

下面，我們通過一些示例性的代碼來分别說明這兩個規則：

​public class FinalExample { int i; // 普通變量 final int j; //final 變量 static FinalExample obj;

​

public void FinalExample () {     // 構造函數 
    i = 1;                        // 寫普通域 
    j = 2;                        // 寫 final 域 
}

public static void writer () {    // 寫線程 A 執行 
    obj = new FinalExample ();
}

public static void reader () {       // 讀線程 B 執行 
    FinalExample object = obj;       // 讀對象引用 
    int a = object.i;                // 讀普通域 
    int b = object.j;                // 讀 final 域 
}

} </pre>

這裡假設一個線程 A 執行 writer () 方法，随後另一個線程 B 執行 reader () 方法。下面我們通過這兩個線程的互動來說明這兩個規則。

寫 final 域的重排序規則

寫 final 域的重排序規則禁止把 final 域的寫重排序到構造函數之外。這個規則的實作包含下面 2 個方面：

  • JMM 禁止編譯器把 final 域的寫重排序到構造函數之外。
  • 編譯器會在 final 域的寫之後，構造函數 return 之前，插入一個 StoreStore 屏障。這個屏障禁止處理器把 final 域的寫重排序到構造函數之外。

現在讓我們分析 writer () 方法。writer () 方法隻包含一行代碼：finalExample = new FinalExample ()。這行代碼包含兩個步驟：

  1. 構造一個 FinalExample 類型的對象；
  2. 把這個對象的引用指派給引用變量 obj。

假設線程 B 讀對象引用與讀對象的成員域之間沒有重排序（馬上會說明為什麼需要這個假設），下圖是一種可能的執行時序：

java final關鍵字_夯實Java基礎系列4：一文了解final關鍵字的特性、使用方法，以及實作原理...

在上圖中，寫普通域的操作被編譯器重排序到了構造函數之外，讀線程 B 錯誤的讀取了普通變量 i 初始化之前的值。而寫 final 域的操作，被寫 final 域的重排序規則“限定”在了構造函數之内，讀線程 B 正确的讀取了 final 變量初始化之後的值。

寫 final 域的重排序規則可以確定：在對象引用為任意線程可見之前，對象的 final 域已經被正确初始化過了，而普通域不具有這個保障。以上圖為例，在讀線程 B“看到”對象引用 obj 時，很可能 obj 對象還沒有構造完成（對普通域 i 的寫操作被重排序到構造函數外，此時初始值 2 還沒有寫入普通域 i）。

讀 final 域的重排序規則

讀 final 域的重排序規則如下：

  • 在一個線程中，初次讀對象引用與初次讀該對象包含的 final 域，JMM 禁止處理器重排序這兩個操作（注意，這個規則僅僅針對處理器）。編譯器會在讀 final 域操作的前面插入一個 LoadLoad 屏障。

初次讀對象引用與初次讀該對象包含的 final 域，這兩個操作之間存在間接依賴關系。由于編譯器遵守間接依賴關系，是以編譯器不會重排序這兩個操作。大多數處理器也會遵守間接依賴，大多數處理器也不會重排序這兩個操作。但有少數處理器允許對存在間接依賴關系的操作做重排序（比如 alpha 處理器），這個規則就是專門用來針對這種處理器。

reader() 方法包含三個操作：

  1. 初次讀引用變量 obj;
  2. 初次讀引用變量 obj 指向對象的普通域 j。
  3. 初次讀引用變量 obj 指向對象的 final 域 i。

現在我們假設寫線程 A 沒有發生任何重排序，同時程式在不遵守間接依賴的處理器上執行，下面是一種可能的執行時序：

java final關鍵字_夯實Java基礎系列4：一文了解final關鍵字的特性、使用方法，以及實作原理...

在上圖中，讀對象的普通域的操作被處理器重排序到讀對象引用之前。讀普通域時，該域還沒有被寫線程 A 寫入，這是一個錯誤的讀取操作。而讀 final 域的重排序規則會把讀對象 final 域的操作“限定”在讀對象引用之後，此時該 final 域已經被 A 線程初始化過了，這是一個正确的讀取操作。

讀 final 域的重排序規則可以確定：在讀一個對象的 final 域之前，一定會先讀包含這個 final 域的對象的引用。在這個示例程式中，如果該引用不為 null，那麼引用對象的 final 域一定已經被 A 線程初始化過了。

如果 final 域是引用類型

上面我們看到的 final 域是基礎資料類型，下面讓我們看看如果 final 域是引用類型，将會有什麼效果？

請看下列示例代碼：

​public class FinalReferenceExample { final int[] intArray; //final 是引用類型 static FinalReferenceExample obj;

​

public FinalReferenceExample () { // 構造函數 intArray = new int[1]; //1 intArray[0] = 1; //2 }

public static void writerOne () { // 寫線程 A 執行 obj = new FinalReferenceExample (); //3 }

public static void writerTwo () { // 寫線程 B 執行 obj.intArray[0] = 2; //4 }

public static void reader () { // 讀線程 C 執行 if (obj != null) { //5 int temp1 = obj.intArray[0]; //6 } } } </pre>

這裡 final 域為一個引用類型，它引用一個 int 型的數組對象。對于引用類型，寫 final 域的重排序規則對編譯器和處理器增加了如下限制：

  1. 在構造函數内對一個 final 引用的對象的成員域的寫入，與随後在構造函數外把這個被構造對象的引用指派給一個引用變量，這兩個操作之間不能重排序。

對上面的示例程式，我們假設首先線程 A 執行 writerOne() 方法，執行完後線程 B 執行 writerTwo() 方法，執行完後線程 C 執行 reader () 方法。下面是一種可能的線程執行時序：

java final關鍵字_夯實Java基礎系列4：一文了解final關鍵字的特性、使用方法，以及實作原理...

在上圖中，1 是對 final 域的寫入，2 是對這個 final 域引用的對象的成員域的寫入，3 是把被構造的對象的引用指派給某個引用變量。這裡除了前面提到的 1 不能和 3 重排序外，2 和 3 也不能重排序。

JMM 可以確定讀線程 C 至少能看到寫線程 A 在構造函數中對 final 引用對象的成員域的寫入。即 C 至少能看到數組下标 0 的值為 1。而寫線程 B 對數組元素的寫入，讀線程 C 可能看的到，也可能看不到。JMM 不保證線程 B 的寫入對讀線程 C 可見，因為寫線程 B 和讀線程 C 之間存在資料競争，此時的執行結果不可預知。

如果想要確定讀線程 C 看到寫線程 B 對數組元素的寫入，寫線程 B 和讀線程 C 之間需要使用同步原語（lock 或 volatile）來確定記憶體可見性。

參考文章

https://www.infoq.cn/article/java-memory-model-6 https://www.jianshu.com/p/067b6c89875a https://www.jianshu.com/p/f68d6ef2dcf0 https://www.cnblogs.com/xiaoxi/p/6392154.html https://www.iteye.com/blog/cakin24-2334965 https://blog.csdn.net/chengqiuming/article/details/70139503 https://blog.csdn.net/hupuxiang/article/details/7362267

微信公衆号

Java技術江湖

如果大家想要實時關注我更新的文章以及分享的幹貨的話，可以關注我的公衆号【Java技術江湖】一位阿裡 Java 工程師的技術小站，作者黃小斜，專注 Java 相關技術：SSM、SpringBoot、MySQL、分布式、中間件、叢集、Linux、網絡、多線程，偶爾講點Docker、ELK，同時也分享技術幹貨和學習經驗，緻力于Java全棧開發！

Java工程師必備學習資源:

一些Java工程師常用學習資源，關注公衆号後，背景回複關鍵字

“Java”

即可免費無套路擷取。

java final關鍵字_夯實Java基礎系列4：一文了解final關鍵字的特性、使用方法，以及實作原理...

個人公衆号：黃小斜

作者是 985 碩士，螞蟻金服 JAVA 工程師，專注于 JAVA 後端技術棧：SpringBoot、MySQL、分布式、中間件、微服務，同時也懂點投資理财，偶爾講點算法和計算機理論基礎，堅持學習和寫作，相信終身學習的力量！

程式員3T技術學習資源：

一些程式員學習技術的資源大禮包，關注公衆号後，背景回複關鍵字

“資料”

即可免費無套路擷取。

java final關鍵字_夯實Java基礎系列4：一文了解final關鍵字的特性、使用方法，以及實作原理...
java final關鍵字 java this關鍵字的使用 java求根号函數 java綁定codesoft變量
上一篇: 【程式人生】一個程式員不敲代碼改寫專欄了，三個月收入……
下一篇: php final 關鍵字的作用什麼?,php中final關鍵字的應用場景

繼續閱讀