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。