final:“这是无法改变的"
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 *///:~
说明:
参数:遵循final修饰变量的约束条件,不能在方法中修改它的值或者指向别的对象。
private void finalParam(final Map param){ param = new HashMap();//报错 param.put("","");//不报错 }
使用final方法的原因:确保在继承中使方法行为保持不变,并且不会被覆盖(设计考虑)。
以下代码可以正确运行:
public class FinalExampleParent { public final void test() { } public final void test(String str) { } }
final和private:
类中所有的private方法都隐式地指定为final的。由于其它类无法取用private方法,因此无法覆盖它。可以对private方法添加final修饰,但没意义。
当类定义为final时,表示该类不可继承。
final类的所有方法都是隐式为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变量的不变性由Javac编译时来保证:(只能在编译期而不能在运行期中检查)
javac编译时,进入数据及控制流分析阶段时,Flow.flow()会涉及以下检查:检查final变量是否有多次赋值,空白final变量是否在构造函数中进行过初始化。
这里参考:javac final变量未赋值检测讲解
final类的不可变性由jvm进行类加载的校验阶段来保证:
JVM类加载的校验阶段中,对元数据验证时,包含final语义校验: 1. 这个类的父类是否继承了不允许被继承的类(被final修饰的类) 2. 类中的字段、方法是否与父类产生矛盾(例如覆盖了父类的final字段,或者出现不符合规则的方法重载,例如方法参数都一致,但返回值类型却不同等)
定义:被final修饰的字段在构造器中一旦被初始化完成,并且构造器没有把“this”的引用传递出去,那么在其他线程中就能看见final字段的值。
如代码所示,变量i与j都具备可见性,它们无须同步就能被其他线程正确访问。
public static final int i; public final int j; static { i = 0; // 省略后续动作 } { // 选择在构造函数中初始化 j = 0; // 省略后续动作 }
解读:
final字段如果声明时赋值,因为只能赋值一次,因此即便存在并发,也能确保只有唯一值
如果在构造函数中赋值,在无引用溢出下,构造函数是线程安全的,因此final字段也是线程安全
这方面内容待研究,或者参考: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的值在被初始化后无法被更改。
设计模式中最重要的两种关系,一种是继承/实现,另外一种是组合关系。所以当遇到不能用继承的,应该考虑用组合:
class MyString{ private String innerString; // ...init & other methods // 支持老的方法 public int length(){ return innerString.length(); // 通过innerString调用老的方法 } // 添加新方法 public String toMyString(){ //... } }
类中所有的private方法都隐式地指定为final,因为其它类无法调用private方法,因此无法覆盖它。可以对private方法添加final修饰,但没意义
参考书籍:《Thinking in Java》 《深入理解java虚拟机》