今天来简单聊一下Java中的final关键字

古城微笑少年丶 2024-03-23 12:19 83阅读 0赞

## 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域重排序规则][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修饰，但没意义

[final]: https://link.juejin.cn?target=https%3A%2F%2Fwww.pdai.tech%2Fmd%2Fjava%2Fthread%2Fjava-thread-x-key-final.html