Java--final关键字

final数据

在Java中，编译器可以将final常量代入任何可能用到它的计算式中，也就是说，可以在编译时进行计算，这减轻了一些运行时的负担。final常量必须是基本类型。

对于对象引用，final使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象。然而，对象其自身却是可以被修改的，既是final又是static的域，将用大写表示，并使用下划线分割各个单词。

---

空白final

一个类中的final域可以做到根据对象不同而有所不同，却又保持恒定不变的特性。

public class BlankFinal {
    private final int i = 0;
    private final int j;
    private final Poppet p;

    public BlankFinal() {
        j = 1;
        p = new Poppet(1);
    }

    public BlankFinal(int x) {
        j = x;
        p = new Poppet(x);
    }

    public static void main(String[] args) {
        new BlankFinal();
        new BlankFinal(47);
    }
}

---

final参数

在参数列表中以声明的方式将参数指明为final，意味着你无法在方法中更改参数引用所指向的对象：

/**
 * Created by paranoid on 17-4-8.
 */
class Gizemo {
    public void spin() {}
}

public class FinalArguments {
    void with(final Gizemo g){
        //! g = new Gizemo(); --g is final
    }

    void without(Gizemo g) {
        g = new Gizemo();
        g.spin();
    }

    //void f(final int i) { i++; }  //--i is only read

    int g(final int i) {
        return i + 1;
    }

    public static void main(String[] args) {
        FinalArguments bf = new FinalArguments();
        bf.without(null);
        bf.with(null);
    }
}

---

final方法（final和private关键字）

import static java.lang.System.out;

/**
 * Created by paranoid on 17-4-8.
 */
class WithFinals {
    private final void f() { out.println("WithFinals.f()"); }
    private void g() { out.println("WithFinals.g()"); }
}

class OverridingPrivate extends WithFinals {
    private final void f() {
        out.println("OverridingPrivate.f()");
    }

    private final void g() {
        out.println("OverridingPrivate.g()");
    }
}

class OverridingPrivate2 extends OverridingPrivate {
    public final void f() {
        out.println("OverridingPrivate2.f()");
    }

    public void g() {
        out.println("OverridingPrivate2.g()");
    }
}

public class FinalOverridingIllusion {
    public static void main(String[] args) {
        OverridingPrivate2 op2 = new OverridingPrivate2();
        op2.f();
        op2.g();

        OverridingPrivate op = op2;
//！        op.f();
//！        op.g();

        WithFinals wf = op2;
//！        wf.f();
//！        wf.g();
    }
}

对于上述出现的问题，只要某方法为private，它就不是基类接口的一部分。它仅是一些隐藏于类中的程序代码，只不过是具有相同的名称而已。如果在导出类中以相同的名称生成一个public，protected或包访问权限方法的话，该方法就不会产生酒类汇总出现的“仅具有相同名称”的情况。此时你并没有覆盖该方法，而是重新生成了一个新方法。

---

final类

当某个类声明成了final时，就表示没打算继承该类，由于final类禁止继承，所以final类中的所有方法都会隐式的指定为final，因此无法覆盖它们。但对于字段（成员变量）并没有指定为final。