Java关键词final解读（简述在java中final关键词的用法和意义）

　　本篇文章为你整理了Java关键词final解读（简述在java中final关键词的用法和意义）的详细内容，包含有java finally关键字简述在java中final关键词的用法和意义 java finalize关键字关于java语言中的final关键字的使用 Java关键词final解读，希望能帮助你了解 Java关键词final解读。

　　目录1 final基本用法1.1 final修饰变量1.2 final修饰方法参数1.3 final修饰方法1.4 final修饰类1.5 空白final1.6 static final2 jvm角度理解final不可变性3 final多线程下可见性4 final域重排序规则5 面试常见问题5.1 所有的final修饰的字段都是编译期常量吗?5.2 final类型的类如何拓展?5.3 如何理解private所修饰的方法是隐式的final?

　　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虚拟机》

　　以上就是Java关键词final解读（简述在java中final关键词的用法和意义）的详细内容，想要了解更多 Java关键词final解读的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读