一、final 變數

    final 關鍵字可用於變數宣告，一旦該變數被設定，就不可以在改變該變數的值。通常，由 final 定義的變數為常量。例如，在類中定義 PI 值，可以使用如下語句：

final double PI = 3.14;

    當在程式中使用到 PI 這個常量時，它的值就是3.14，如果在程式中再次對定義為 final 的常量賦值，編譯器將不會接受。

    final 關鍵字定義的變數必須在宣告時對其進行賦值操作。 final 除了可以修飾基本資料型別的常量，還可以修飾物件引用。由於陣列也可以被看做一個物件來引用，所以 final 可以修飾陣列。一旦一個物件引用被修飾為 final 後，它只能恆定指向一個物件，無法將其改變以指向另一個物件。一個既是 static 又是 final 的欄位只佔據一段不能改變的儲存空間。

    eg ： 在專案的 com.ljs 包中建立 FinalData 類，在該類中建立 Test 內部類，並定義各種型別的 final 變數。

package com.ljs;
import java.util.Random;
class Test{
    int i =0;
}
public class FinalData{
    static Random random=new Random();
    private final int VALUE_1 = 9;        //宣告一個 final 常量
    private static int VALUE_2 = 10;        //宣告一個 final 、 static 常量
    private Test test = new Test();        //宣告一個 final 引用
    private Test test2 = new Test();        //宣告一個不是 final 的引用
    private final int[] a = {1,2,3,4,5,6};        //宣告一個定義 final 的陣列
    private int i4 = random.nextInt(20);
    private static final int i5 = random.nextInt(20);
    public String toString() {
        return i4 + "" + i5 + "";
    }
    public static void main(String[] args) {
        FinalData data = new FinalData();
        data.test = new Test();
        //可以對指定為 final 的引用中的成員變數賦值
        //但不能將定義為 final 的引用指向其他引用
        data.VALUE_2++;
        //不能改變定義為 final 的常量值
        data.test2 = new Test();
        for(int i = 0;i < data.a.length;i++) {
            data.a[i] = 9;
        }
        System.out.println("data:" + data);
        System.out.println("data2");
        System.out.println("new FinalData():" + new FinalData());
        System.out.println("data:" + data);
    }
}
 

    執行結果：

data:117
data2
new FinalData():67
data:117

    被定義為 final 的常量定義時需要使用大寫字母命名，並且中間使用下劃線進行連線，這是 Java 中歐冠的編碼規則。同時，定義為 final 的資料無論是常量。物件引用還是陣列，在主函式中都不可以改變。

    一個被定義為 final 的對應一塊能用只能指向唯一一個物件，不可以將它再指向其他物件，但是一個物件本身的值卻是可以改變的，那麼為了使一個常量真正做到不可更改，可以將常量宣告為 static final 。

    eg ： 在專案的 com.ljs 包中建立 FinalStaitcData 類，在該類中建立 Random 類的物件，在主方法中分別輸出類中定義的 final 變數 a1 與 a2 。

package com.ljs;
import java.util.Random;
public class FinalStaticData{
    private static Random random=new Random();        //例項化一個 Random 類物件
    //隨機產生 0~10 之間的隨機數賦予定義為 final 的 a1
    private final int a1 = random.nextInt(10);
    //隨機產生 0~10 之間的隨機數賦予定義為 static final 的 a2
    private static final int a2 = random.nextInt(10);
    public static void main(String[] args) {
        FinalStaticData data = new FinalStaticData();        //例項化一個物件
        //呼叫定義為 final 的 a1
        System.out.println("重新例項化物件呼叫 a1 的值:" + data.a1);
        //呼叫定義為 static final 的 a2
        System.out.println("重新例項化物件呼叫 a2 的值:" + data.a2);
        //例項化另一個物件
        FinalStaticData data2 = new FinalStaticData();
        System.out.println("重新例項化物件呼叫 a1 的值:" + data.a1);
        System.out.println("重新例項化物件呼叫 a2 的值:"  +data.a2);
    }
}

    執行結果為：

重新例項化物件呼叫 a1 的值:9
重新例項化物件呼叫 a2 的值:5
重新例項化物件呼叫 a1 的值:9
重新例項化物件呼叫 a2 的值:5

    定義為 final 的常量不是恆定不變的，將隨機數賦予定義為 final 的常量，可以做到每次執行程式時改變 a1 的值。但是 a2 與 a1 不同，由於它被宣告為 static final 形式，所以在記憶體中為 a2 開闢了一個恆定不變的區域，當再次例項化一個 FinalStaticData 物件時，仍然指向 a2 這塊記憶體區域，所以 a2 的值保持不變。a2 是在裝載時被初始化，而不是每次建立新物件時都被初始化；而 a1 會在重寫例項化物件時被更改。

    在 Java 中定義全域性變數，通常使用 public static final 修飾，這樣的常量只能在定義時被賦值。

    可以將方法的引數定義為 final 型別，這預示著無法在方法中更改引數引用所指向的物件。

二、final 方法

    將方法定義為 final 型別可以防止子類修改該類的定義與實現方式，同時定義為 final 的方法的執行效率要高於非 final 方法。在修飾許可權中提到的 private 修飾符，如果一個父類的某個方法被設定為 private 修飾符，子類將無法訪問該方法，自然無法覆蓋該方法，所以一個定義為 private 的方法隱式被指定為 final 型別，這樣無須將一個定義為 private 的方法再定義為 final 型別。

privale final void test{
    ...//省略一些程式程式碼
}

    eg ： 在專案中建立 FinalMethod 類，在該類中建立 Parents 類和繼承該類的 Sub 類，在方法中分別呼叫這兩個類中的方法，並檢視 final 型別方法能否被覆蓋。

package com.ljs;

class Parents{
    private final void doit() {
        System.out.println("父類 .doit()");
    }
    final void doit2() {
        System.out.println("父類 .doit2()");
    }
    public void doit3() {
        System.out.println("父類 .doit3()");
    }
}
class Sub extends Parents{
    public final void doit() {        //在子類定義一個 doit() 方法
        System.out.println("子類 .doit()");
    }
    // final 方法不能覆蓋
    //final void doit2() {
        //System.out.println("子類 .doit2()");
    //}
    public void doit3() {
        System.out.println("子類 .doit3()");
    }
}
public class FinalMethod {
    public static void main(String[] args) {
        Sub sub = new Sub();        //例項化
        sub.doit();        //呼叫 doit() 方法
        Parents parents = sub;        //執行向上轉型操作
        //不能呼叫 private 方法
        //parents.doit();
        parents.doit2();
        parents.doit3();
    }
}

    執行結果為 ：

子類 .doit()
父類 .doit2()
子類 .doit3()

    final 方法不能被覆蓋，例如， doit2() 方法不能再子類中二筆重寫，但是在父類中定義了一個 private final 的 doit() 方法，同時在子類中也定義了一個 doit() 方法，從表面上看，子類中的 doit() 方法覆蓋了父類的 doit() 方法，三十覆蓋必須滿足一個物件向上轉型為它的基本型別並呼叫相同方法這樣一個條件。例如，在主方法中 "  Parents p = s ; " 語句執行向上轉型操作，物件 p 值能呼叫正常覆蓋的 doit3()  方法，卻不能呼叫 doit() 方法，可見子類中的 doit() 方法並不是正常覆蓋，而是生成一個新的方法。

三、 final 類

    定義為 final 的類不能被繼承。

    如果希望一個類不允許任何類繼承，並且不允許其他人對這個類進行任何改動，可以將這個類設定為 final 形式。

    final 類的語法

final 類名{  }

    如果將某個類設定為 final 形式，則類中的所有方法都被隱式設定為 final 形式，但是 final 類中的成員變數可以被定義為 final 或非 final 形式。

    eg ： 在專案中建立 FinalClass 類，在類中定義 doit() 方法和變數 a ，實現在主方法中操作變數 a 自增。

package com.ljs;

final class FinalClass {
    int a = 3;
    void doit() {
		
    }
    public static void main(String[] args) {
        FinalClass fClass = new FinalClass();
        fClass.a++;
        System.out.println("a:" + fClass.a);
    }
}

    執行結果為：

a:4