开启生长之旅！这是我参加「日新方案 12 月更文挑战」的第26天，点击检查活动概况

1 final根本用法

final：“这是无法改动的”
final能够润饰：变量、参数、办法、类

1.1 final润饰变量

润饰变量（变量、局部变量），当变量类型为：

• 根本类型，一旦被赋值，该值不能被改动。
• 引证类型，一旦引证被初始化指向一个目标，就不能指向其他目标，但目标内容能够被修正
• 数据类型：数组也是引证类型

分析以下代码：

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; }
    //编译时常量
    private final int valueOne = 9;
    private static final int VALUE_TWO = 99;
    public static final int VALUE_THREE = 39;
    //非编译时常量
    private final int i4 = rand.nextInt(20);
    static final int INT_5 = rand.nextInt(20);
    private Value v1 = new Value(11);
    private final Value v2 = new Value(22);
    private 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: can’t change value
        fd1.v2.i++; // OK：引证指向的目标内容可变
        fd1.v1 = new Value(9); // OK ：非final，引证可变
        for(int i = 0; i < fd1.a.length; i++)
            fd1.a[i]++; // Object isn’t constant!
        //! fd1.v2 = new Value(0); // Error: final引证不行变
        //! fd1.VAL_3 = new Value(1); //Error: final引证不行变
        //! fd1.a = new int[3];
        System.out.println(fd1);
        System.out.println("Creating new FinalData");
        FinalData fd2 = new FinalData("fd2");
        System.out.println(fd1);
        System.out.println(fd2);
    }
}
/* 运转成果:
fd1: i4 = 15, INT_5 = 18
Creating new FinalData
fd1: i4 = 15, INT_5 = 18
fd2: i4 = 13, INT_5 = 18
*///:~

阐明：

1. valuOne和VALUE_TWO：都是编译期常量，无严重区别。
2. VAL_THREE：典型的对常量界说的办法：界说为public,则能够被用于包之外；界说为static，则着重只有一份；界说为final,则阐明它是一个常量。注意这种类型常量的命名办法（大写和下划线）
3. i4和INT_ 5：final变量不代表编译时可知它的值，能够在运转时初始化值。例如在运转时运用随机生成的数值来初始化
4. v1、v2、VAL_3 阐明final引证的特征
5. 特别注意：INT_5：不能够经过创立第二个FinalData目标而加以改动。由于它是static的，在装载时已被初始化，而不是每次创立新目标时都初始化。

1.2 final润饰办法参数

参数：遵从final润饰变量的约束条件，不能在办法中修正它的值或许指向其他目标。

 private void finalParam(final Map param){
    param = new HashMap();//报错
    param.put("","");//不报错
 }

1.3 final润饰办法

运用final办法的原因：确保在承继中使办法行为坚持不变，而且不会被掩盖（规划考虑）。

• final润饰的办法不能够重写（重写发生在父类与之类）
• final润饰的办法能够重载（同一个类）

以下代码能够正确运转：

public class FinalExampleParent {
    public final void test() {
    }
    public final void test(String str) {
    }
}

final和private：

类中一切的private办法都隐式地指定为final的。由于其它类无法取用private办法，因而无法掩盖它。能够对private办法增加final润饰，但没含义。

1.4 final润饰类

当类界说为final时，表明该类不行承继。
final类的一切办法都是隐式为final，由于无法掩盖它们

1.5 空白final

界说：被声明为final但又未给定初值的域。
用途：提供了更大的灵活性：一个类中的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
    //空final结构器中初始化
    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) {
    //空final域在不同景象下赋予不一样的初值
        new BlankFinal();
        new BlankFinal(47);
    }
}

阐明：

1. 必须在域的界说处或许每个结构器中对final赋值，这正是fnal域在运用前总是被初始化的原因地点。
2. 一个类中的final域能够依据目标而有所不同，却又坚持其不变的特性。

1.6 static final

1. 一起是static final 的字段占据一段不能改动的存储空间，它必须在界说的时候进行赋值，否则编译器将不予经过【即使在结构函数中初始化也不行】。
2. static润饰的字段并不归于一个目标，而是归于这个类的。【对一个类创立多个目标，其static final 润饰的变量其实是指向同一个值】

2 jvm视点了解final不行变性

一、Javac编译器
final变量的不变性由Javac编译时来保证：（只能在编译期而不能在运转期中检查）

javac编译时，进入数据及操控流分析阶段时，
Flow.flow()会涉及以下检查：检查final变量是否有屡次赋值，空白final变量是否在结构函数中进行过初始化。

二、JVM类加载
final类的不行变性由jvm进行类加载的校验阶段来保证：

JVM类加载的校验阶段中，对元数据验证时，包含final语义校验：
1. 这个类的父类是否承继了不允许被承继的类（被final润饰的类）
2. 类中的字段、办法是否与父类产生矛盾
（例如掩盖了父类的final字段，或许呈现不符合规矩的办法重载，例如办法参数都共同，但返回值类型却不同等）

3 final多线程下可见性

界说：被final润饰的字段在结构器中一旦被初始化完成，而且结构器没有把“this”的引证传递出去，那么在其他线程中就能看见final字段的值。
如代码所示，变量i与j都具备可见性，它们无须同步就能被其他线程正确拜访。

public static final int i;
public final int j;
static {
    i = 0;
    // 省掉后续动作 
}
{
    // 选择在结构函数中初始化
    j = 0;
    // 省掉后续动作
}

解读：
final字段假如声明时赋值，由于只能赋值一次，因而即便存在并发，也能确保只有唯一值
假如在结构函数中赋值，在无引证溢出下，结构函数是线程安全的，因而final字段也是线程安全

4 final域重排序规矩

这方面内容仍在研讨，或许参阅：final域重排序规矩

5 面试常见问题

5.1 一切的final润饰的字段都是编译期常量吗?

不是
编译期常量指的便是程序在编译时就能确认这个常量的具体值
非编译期常量便是程序在运转时才能确认常量的值 (运转时常量)

public class Test {
    //编译期常量
    final int i = 1;
    final static int J = 1;
    //非编译期常量
    Random r = new Random();
    final int k = r.nextInt();
}

k的值由随机数目标决定，所以不是一切的final润饰的字段都是编译期常量，仅仅k的值在被初始化后无法被更改。

5.2 final类型的类如何拓展?

规划模式中最重要的两种关系，一种是承继/实现，另外一种是组合关系。所以当遇到不能用承继的，应该考虑用组合：

class MyString{
    private String innerString;
    // ...init & other methods
    // 支持老的办法
    public int length(){
        return innerString.length(); // 经过innerString调用老的办法
    }
    // 增加新办法
    public String toMyString(){
        //...
    }
}

5.3 如何了解private所润饰的办法是隐式的final?

类中一切的private办法都隐式地指定为final，由于其它类无法调用private办法，因而无法掩盖它。能够对private办法增加final润饰，但没含义

参阅书本：《Thinking in Java》 《深化了解java虚拟机》