1、被final修飾的類不能被繼承

經典案例就是java.lang.String類

public final class String implements java.io.Serializable, Comparable<String>, CharSequence

還有一些常見的類也是被final所修飾的，如下：基本類型對應的包裝類型（如java.lang.Integer、java.lang.Long等）、字符相關類（java.lang.StringBuilder、java.lang.StringBuffer)、系統類（java.lang.Class、java.lang.System）等。

是Java語法所規定，如此設計的目的：類不需要被拓展、實現細節不允許改變，估計是為了安全考慮。

2、被final修飾的方法不能被重寫

另外，不能被重寫或者覆蓋的方法還有：構造方法（也是靜態方法）、靜態方法、私有方法（子類中不可見，所以不允許重寫）

同樣是Java語法規定，不允許改變方法的實現。

靜態方法為何不可以被子類重寫？

靜態方法的調用是編譯器編譯時靜態綁定的，而實例方法的調用是在運行時動態綁定的；靜態方法無法像實例方法那樣在運行時動態確定方法的實現，所以靜態方法的復寫沒有意義。

另外，因為二者的調用的方式不同，所以子類中不可以聲明和父類中方法同名的靜態方法；即：靜態方法不能隱藏實例方法，

但是 靜態方法可以被子類的同名靜態方法隱藏（實際這時，這已經是兩個不相關的方法）

因為調用方式一致，不會像上面造成歧義，雖然父類和子類都定義了同樣的函數，但是編譯器會根據對象的靜態類型激活對應的靜態方法的引用，造成了重寫的假象，實則不是重寫！

附加Java多態的實現

package com.learn.pra06;
public class ClassReference {
    static class Person {
        @Override
        public String toString(){
            
 
return "I‘m a person.";
        }
        public void eat(){
            System.out.println("Person eat");
        }
        public void speak(){
            System.out.println("Person speak");
        }

    }
    static class Boy extends Person{
        @Override
        public String toString(){
            return "I‘m a boy";
        }
        @Override
        public void speak(){
            System.out.println("Boy speak");
        }
        public void fight(){
            System.out.println("Boy fight");
        }
    }
    static class Girl extends Person{
        @Override
        public String toString(){
            return "I‘m a girl";
        }
        @Override
        public void speak(){
            System.out.println("Girl speak");
        }
        public void sing(){
            System.out.println("Girl sing");
        }
    }
    public static void main(String[] args) {
        Person boy = new Boy();
        Person girl = new Girl();
        System.out.println(boy);
        boy.eat();
        boy.speak();
        System.out.println(girl);
        girl.eat();
        girl.speak();
    }
}

首先看看方法表在內存的模型：

通過看Girl和Boy方法表可以看出繼承的方法從頭到尾開始排列，並且方法引用在子類的中都有固定索引，即都有相同的偏移量；若子類重寫父類某個方法，就會使子類方法表原先存父類的方法引用變成重寫後方法的引用，到這就應該理解為什麽可以根據對象類型而調用到正確的方法，關鍵就在於方法表。

總體流程就是：編譯器將類編譯成class文件，其中方法會根據靜態類型從而將對應的方法引用寫入class中，運行時，JVM會根據INVOKEVIRTUAL 所指向的方法引用在方法區找到該方法的偏移量，再根據this找到引用類型真實指向的對象，訪問這個對象類型的方法表，根據偏移量找出存放目標方法引用的位置，取出這個引用，調用這個引用實際指向的方法，完成多態！

以上均參考 https://blog.csdn.net/dawn_after_dark/article/details/74357049

3、被final修飾的變量不能被“改變”

1）被final修飾的變量不像static那樣，它也可以修飾局部變量。

2）被final修飾的變量一定要被初始化，否則編譯不通過。

初始化有兩種：直接在變量定義時初始化 和 在構造函數中初始化（每個構造函數都要初始化即每個實例化對象的入口都要進行初始化）。

3）被final修飾的基本類型變量，它的值是不可變的。被final修飾的引用類型變量，它的引用地址是不可變的，對象裏的內容是可變的。

4、在匿名內部類中使用外部方法的局部變量（也可能是函數的參數形式）時，該變量必須被final修飾。

1）原因：匿名內部類裏面使用外部方法中的局部變量時，其實就是內部類的對象在使用它，內部類對象生命周期中都可能調用它，而內部類對象試圖訪問外部方法中的局部變量時，外部方法的局部變量很可能已經不存在了（方法執行完，局部變量便從棧中彈出，生命周期結束不復存在了），那麽就得延續其生命，拷貝到內部類中，而拷貝會帶來不一致性，從而需要使用final聲明保證一致性。

==》為了解決內部類實例與外部方法局部變量生命周期不同的問題，匿名內部類備份了變量，為了解決備份變量引起的修改後沒有同步修改的問題，外部變量需要被定義成final ==》 匿名內部類使用final不是怕修改，是怕不能同步修改。

2）匿名內部類使用外部類的成員變量是不需要是final的。 因為內部類本身都會含有一個外圍了的引用（外圍類.this），所以回調的時候一定可以訪問到

private Animator createAnimatorView(final View view, final int position) {
    MyAnimator animator = new MyAnimator();
    animator.addListener(new AnimatorListener() {
        @Override
        public void onAnimationEnd(Animator arg0) {
            Log.d(TAG, "position=" + position); 
        }
    });
    return animator;
}

內部類回調裏訪問position的時候createAnimatorView()早就執行完了，position如果不是final的，回調的時候肯定就無法拿到它的值了，因為局部變量在函數執行完了以後就被回收了。

以上參考 https://www.cnblogs.com/DarrenChan/p/5738957.html

附加 通過反編譯查看傳遞給匿名內部類的參數

public interface MyInterface {
    void doSomething();
}


public class TryUsingAnonymousClass {
    public void useMyInterface() {
        final Integer number = 123;
        System.out.println(number);

        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println(number);
            }
        };
        myInterface.doSomething();

        System.out.println(number);
    }
}

我們進行反編譯，結果是：

class TryUsingAnonymousClass$1 implements MyInterface {
    private final TryUsingAnonymousClass this$0;
    private final Integer paramInteger;

    TryUsingAnonymousClass$1(TryUsingAnonymousClass this$0, Integer paramInteger) {
        this.this$0 = this$0;
        this.paramInteger = paramInteger;
    }

    public void doSomething() {
        System.out.println(this.paramInteger);
    }
}

可以看到：外部類的實例引用 this$0 和外部方法局部變量 number 都作為構造方法的參數傳入了匿名內部類。

5、final變量與普通變量有什麽區別，什麽時候可以相等？

public class FinalTest2 {

    public static void main(String[] args) {
        final String str1 = "test";
        final String str2 = getContent();
        String str3 = "test";
        
        String str4 = str1 + "";
        String str5 = str2 + "";
        
        System.out.println(str3 == str4);
        System.out.println(str3 == str5);
    }
    public static String getContent(){
        return "test";
    }
}

輸出後的結果為true和false。這是為什麽呢？

如果是final修飾直接定義的字符串或者是基本類型，它在編譯期間就會確定其值，則編譯器會把它當做常量，放在常量池中。所以當有使用到它的地方會直接用常量替換（str1 str3 str4都是常量池中的同一個常量）。而其他都是運行時才會確定的值，所以依然使用變量去計算。在代碼中str2變量，雖然用是final修飾但是它的值要在的運行時才能確定，所以它相當於普通變量。而str5的生成，因為str2是普通變量，所以str5會通過StringBulider去計算整個表達式的值，返回一個新的String，引用地址變了。所以第12行的輸出為false;

6、final與finally 和finalize的區別

finally是異常處理語句結構的一部分，表示最終執行。

finalize是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，供垃圾收集時的其他資源回收，例如關閉文件等。

參考：https://www.cnblogs.com/yuanfy008/p/8021673.html

final關鍵字總結