final关键字总结

一、被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语法所规定，如此设计的目的：类不须要被拓展、实现细节不容许改变，估计是为了安全考虑。

二、被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

三、被final修饰的变量不能被“改变”

1）被final修饰的变量不像static那样，它也能够修饰局部变量。

2）被final修饰的变量必定要被初始化，不然编译不经过。

初始化有两种：直接在变量定义时初始化 和 在构造函数中初始化（每一个构造函数都要初始化即每一个实例化对象的入口都要进行初始化）。

3）被final修饰的基本类型变量，它的值是不可变的。被final修饰的引用类型变量，它的引用地址是不可变的，对象里的内容是可变的。

四、在匿名内部类中使用外部方法的局部变量（也多是函数的参数形式）时，该变量必须被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 都做为构造方法的参数传入了匿名内部类。

五、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;

六、final与finally 和finalize的区别

finally是异常处理语句结构的一部分，表示最终执行。

 

finalize是Object类的一个析构方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其余资源回收，例如关闭文件等。

当垃圾回收器将要释放无用对象的内存时，先调用该对象的finalize()方法。若是在程序终止前垃圾回收器始终没有执行垃圾回收操做，那么垃圾回收器将始终不会调用无用对象的finalize()方法。在Java的Object基类中提供了protected类型的finalize()方法，所以任何Java类均可以覆盖finalize()方法，一般，在析构方法中进行释放对象占用的相关资源的操做。

Java 虚拟机的垃圾回收操做对程序彻底是透明的，所以程序没法预料某个无用对象的finalize()方法什么时候被调用。若是一个程序只占用少许内存，没有形成严重的内存需求，垃圾回收器可能没有释放那些无用对象占用的内存，所以这些对象的finalize()方法尚未被调用，程序就终止了。

程序即便显式调用System.gc()或Runtime.gc()方法，也不能保证垃圾回收操做必定执行，也就不能保证对象的finalize()方法必定被调用。

当垃圾回收器在执行finalize()方法的时候，若是出现了异常，垃圾回收器不会报告异常，程序继续正常运行。

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