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 *///:~

说明：

valuOne和VALUE_TWO：都是编译期常量                ，无重大区别 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 。 VAL_THREE：典型的对常量定义的方式：定义为public,则可以被用于包之外；定义为static

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 
，则强调只有一份；定义为final,则说明它是一个常量
















。注意这种类型常量的命名方式（大写和下划线） i4和INT_ 5：final变量不代表编译时可知它的值















，可以在运行时初始化值 
  
  
  
  
  
  
  
 。例如在运行时使用随机生成的数值来初始化 v1
   
   
   
   
   
   
   
   
、v2
 

 

 

 

 

 

 

 
、VAL_3 说明final引用的特征 特别注意：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); } }

说明：

必须在域的定义处或者每个构造器中对final赋值 
 
 
 
 
 
 
 
 ，这正是fnal域在使用前总是被初始化的原因所在 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 。 一个类中的final域可以根据对象而有所不同
   
   
   
   
   
   
   
   
，却又保持其不变的特性
























。

1.6 static final

同时是static final 的字段占据一段不能改变的存储空间
 

 

 

 

 

 

 

 
，它必须在定义的时候进行赋值 

 

 

 

 

 

 

 

 ，否则编译器将不予通过【即使在构造函数中初始化也不行】                。 static修饰的字段并不属于一个对象                ，而是属于这个类的 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 。【对一个类创建多个对象

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 
，其static final 修饰的变量其实是指向同一个值】

2 jvm角度理解final不可变性

一 

 

 

 

 

 

 

 

 、Javac编译器

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















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
















。

这里参考：javac 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虚拟机》