深入理解final关键字

Java中的final关键字通常代表“这是无法改变的”。不能改变通常可能出于以下两种理由：设计或效率。

下面详细介绍了可能用到final的三种情况：数据、方法和类。

一、final数据

final数据总共分为以下三种：final变量、空白final、final参数，下面分别介绍一下：

final变量

在编程的过程中，我们通常需要向编译器告知一块数据是恒定不变的。如：

1. 一个永不改变的 编译时变量。
2. 一个在运行时被初始化的值，而你不希望它被改变。

对于编译期常量这种情况，编译器可以将该常量值带入任何可能用到它的计算式中，也就是说，可以在编译时执行计算式，这减轻了一些运行时的负担。编译期常量必须是基本数据类型，并且以final表示。在对这个常量进行定义的时候，必须对其进行赋值。final修饰的基本数据类型，final使数值恒定不变。

对于对象引用，final使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象。然而，对象其自身却是可以被修改的，java并未提供使任何对象恒定不变的途径。这一限制同样适用数组，它也是对象。

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;
    }

    // Can be compile-time constants:
    private final int valueOne = 9;
    private static final int VALUE_TWO = 99;
    // Typical public constant:
    public static final int VALUE_THREE = 39;
    // final修饰在编译时并需要知道值是多少，
    private final int i4 = rand.nextInt(20);
    //使用static修饰，则代表这有一份，不管创建多少个对象，int_5的值都是不会改变的。
    static final int INT_5 = rand.nextInt(20);
    private Value v1 = new Value(11);
    private final Value v2 = new Value(22);
    /**
     * 定义常量：
     * public 代表可以在包外进行访问
     * static 代表只有一份
     * final 代表它是一个常量
     *
     * 命名规范：使用final static修饰的基本类型全用大写字母命名，并且字与字之间用下划线隔开
     * */
    public 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: final修饰的常量，不能改变值
        fd1.v2.i++; // v2不是常量，可以改变值
        fd1.v1 = new Value(9); // 不是final类型的引用可以指向一个新的对象
        for (int i = 0; i < fd1.a.length; i++)
            fd1.a[i]++; // a不是常量，可以改变值
        //! fd1.v2 = new Value(0); // Error: fianl修饰不能将引用指向一个新的对象
        //! fd1.VAL_3 = new Value(1); // fianl修饰不能将引用指向一个新的对象
        //! fd1.a = new int[3]; //fianl修饰不能将引用指向一个新的对象
        System.out.println(fd1);
        System.out.println("Creating new FinalData");
        FinalData fd2 = new FinalData("fd2");
        System.out.println(fd1);
        System.out.println(fd2);
    }
} /* Output:
fd1: i4 = 15, INT_5 = 18
Creating new FinalData
fd1: i4 = 15, INT_5 = 18
fd2: i4 = 13, INT_5 = 18
*///:~

注意：
一个既是static又是final的域只占据一段不能改变的存储空间。

空白final

java允许生成“空白final”，所谓空白final是指被声明为final但又未给定初值的域。无论什么情况，编译器都确保空白final在使用前必须被初始化。但是，空白fianl在关键字的使用上提供了更大的灵活性，此外，一个类中的final域就可以做到根据对象而有所不同，却又保持其恒定不变的特性。下面即为一例。

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

    // Blank finals MUST be initialized in the constructor:
    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) {
        new BlankFinal();
        new BlankFinal(47);
    }
} ///:~

必须在域的定义处或者每个构造器中用表达式对fianl进行赋值，这正式fianl域在使用前总是被初始化的原因所在。

fianl参数

Java允许在参数列表中以声明的方式将参数指明为final。这意味着你无法在方法中更改参数所指向的对象：

class Gizmo {
    public void spin() {
    }
}

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

    void without(Gizmo g) {
        g = new Gizmo(); // OK -- g not final
        g.spin();
    }

    // void f(final int i) { i++; } // Can't change
    // You can only read from a final primitive:
    int g(final int i) {
        return i + 1;
    }

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

方法f()和g()展示了当基本类型的参数被指明为final时所出现的结果：你可以读参数，但却无法修改参数。这一特性主要用来向匿名内部类传递数据。

二、final方法

使用final来修饰方法的原因主要有两个。
1. 第一个原因是把方法锁定，以防任何继承类修改它的含义。这是出于设计的考虑：确保在继承中使方法行为保持不变，并且不会被覆盖。
2. 效率。在Java早期的实现版本中，如果一个方法指明为final，就是同意编译器将针对该方法的所有调用转为内嵌调用。当编译器发现一个final方法调用命令时，

final和private关键字

类中所有的private方法都隐式地指定为是final的。由于无法取用private方法，所以也就无法覆盖它。可以对private方法添加final修饰词，但这并不能给该方法增加任何额外的意义。

class WithFinals {
  // private 与 final 意义相同
  private final void f() { System.out.println("WithFinals.f()"); }
  private void g() { System.out.println("WithFinals.g()"); }
}

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

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

public class FinalOverridingIllusion {
  public static void main(String[] args) {
    OverridingPrivate2 op2 = new OverridingPrivate2();
    op2.f();
    op2.g();
    // You can upcast:
    OverridingPrivate op = op2;
    // But you can't call the methods:
    //! op.f();
    //! op.g();
    // Same here:
    WithFinals wf = op2;
    //! wf.f();
    //! wf.g();
  }
} /* Output:
OverridingPrivate2.f()
OverridingPrivate2.g()
*///:~

覆盖只有在某方法是基类的接口的一部分时才会出现。即，必须能将一个对象向上转型为它的基本类型并调用相同的方法。如果某方法为private，他就是不是基本类的接口的一部分。它仅是一些隐藏于类中的程序代码，只不过是具有相同的名称而已。但如果在导出类中以相同的名称生成一个public、protected或包访问权限方法的话，该方法就不会产生在基类中出现的“仅具有相同名称”的情况。此时你并没有覆盖该方法，仅是生成了一个新的方法。

三、final类

当将某个类的整体定义为final时，就表明你不打算继承该类，而且也不允许别人这样做。换句话说，出于某种考虑，你对该类的设计永远不需要做任何变动，或者出于安全的考虑，你不希望它有子类。

class SmallBrain {}

final class Dinosaur {
  int i = 7;
  int j = 1;
  SmallBrain x = new SmallBrain();
  void f() {}
}

//! class Further extends Dinosaur {}
// error: 不能继承final类dinosaur

public class Jurassic{
  public static void main(String[] args) {
    Dinosaur n = new Dinosaur();
    n.f();
    n.i = 40;
    n.j++;
    n.x = new SmallBrain();
    System.out.println(n.i);
    System.out.println(n.j);
  }
} /*Output:
40
2
*///:~

请注意，final类的域可以根据个人的意愿选择为是或不是fianl。不论类是否被定义为final，相同的规则都适用于定义为final的域。由于final类禁止继承，所以fianl类中所有的方法都隐式指定为是fianl的，因为无法覆盖它们。而fianl类中的数据则不是fianl类型的，可以被改变。