import java.util.Random;
class Value {
    int i; // Package access
    public Value(int i) { this.i = i; }
}
public class FinalData {
    private static Random rand = new Random(47);
    private String id;
    public FinalData(String id) { this.id = id; }
    //編譯時常量
    private final int valueOne = 9;
    private static final int VALUE_TWO = 99;
    public static final int VALUE_THREE = 39;
    //非編譯時常量
    private final int i4 = rand.nextInt(20);
    static final int INT_5 = rand.nextInt(20);
    private Value v1 = new Value(11);
    private final Value v2 = new Value(22);
    private static final Value VAL_3 = new Value(33);
    // Arrays:
    private final int[] a = { 1, 2, 3, 4, 5, 6 };
    public String toString() {
        return id + ": " + "i4 = " + i4 + ", INT_5 = " + INT_5;
    }

    public static void main(String[] args) {
        FinalData fd1 = new FinalData("fd1");
        //! fd1.valueOne++; // Error: can't change value
        fd1.v2.i++; // OK：引用指向的對象內容可變
        fd1.v1 = new Value(9); // OK ：非final，引用可變
        for(int i = 0; i < fd1.a.length; i++)
            fd1.a[i]++; // Object isn't constant!
        //! fd1.v2 = new Value(0); // Error: final引用不可變
        //! fd1.VAL_3 = new Value(1); //Error: final引用不可變
        //! fd1.a = new int[3];
        System.out.println(fd1);
        System.out.println("Creating new FinalData");
        FinalData fd2 = new FinalData("fd2");
        System.out.println(fd1);
        System.out.println(fd2);
    }
}
/* 運行結果:
fd1: i4 = 15, INT_5 = 18
Creating new FinalData
fd1: i4 = 15, INT_5 = 18
fd2: i4 = 13, INT_5 = 18
*///:~

 private void finalParam(final Map param){
    param = new HashMap();//報錯
    param.put("","");//不報錯
 }

public class FinalExampleParent {
    public final void test() {
    }
    public final void test(String str) {
    }
}

class Poppet {
    private int i;
    Poppet(int ii) { i = ii; }
}
public class BlankFinal {
    private final int i = 0; // Initialized final
    private final int j; // Blank final
    private final Poppet p; // Blank final reference
    //空final構造器中初始化
    public BlankFinal() {
        j = 1; // Initialize blank final
        p = new Poppet(1); // Initialize blank final reference
    }
    public BlankFinal(int x) {
        j = x; // Initialize blank final
        p = new Poppet(x); // Initialize blank final reference
    }
    public static void main(String[] args) {
    //空final域在不同情形下賦予不一樣的初值
        new BlankFinal();
        new BlankFinal(47);
    }
}

javac編譯時，進入數(shù)據(jù)及控制流分析階段時，F(xiàn)low.flow()會涉及以下檢查：檢查final變量是否有多次賦值，空白final變量是否在構造函數(shù)中進行過初始化。

JVM類加載的校驗階段中，對元數(shù)據(jù)驗證時，包含final語義校驗：
1. 這個類的父類是否繼承了不允許被繼承的類（被final修飾的類）
2. 類中的字段、方法是否與父類產(chǎn)生矛盾（例如覆蓋了父類的final字段，或者出現(xiàn)不符合規(guī)則的方法重載，例如方法參數(shù)都一致，但返回值類型卻不同等）

public static final int i;
public final int j;
static {
    i = 0;
    // 省略后續(xù)動作 
}
{
    // 選擇在構造函數(shù)中初始化
    j = 0;
    // 省略后續(xù)動作
}

public class Test {
    //編譯期常量
    final int i = 1;
    final static int J = 1;
    //非編譯期常量
    Random r = new Random();
    final int k = r.nextInt();
}

class MyString{
    private String innerString;
    // ...init & other methods
    // 支持老的方法
    public int length(){
        return innerString.length(); // 通過innerString調用老的方法
    }
    // 添加新方法
    public String toMyString(){
        //...
    }
}