Java中final关键字的深入探究

前言

final 关键字的字面意思是最终的,不可修改的。这似乎是一个看见名字就大概知道怎么用的语法,但你是否有深究过final在各个场景中的具体用法,注意事项,以及背后涉及的Java设计思想呢?

一. final 修饰变量

1. 基础: final 修饰基本数据类型变量和引用数据类型变量

相信大家都具备基本的常识: 被 final 修饰的变量是不能够被改变的。但是这里的”不能够被改变”对于不同的数据类型是有不同的含义的。

当 final 修饰的是一个基本数据类型数据时,这个数据的值在初始化后将不能被改变;

当 final 修饰的是一个引用类型数据时,也就是修饰一个对象时,引用在初始化后将永远指向一个内存地址,不可修改。但是该内存地址中保存的对象信息,是可以进行修改的。

上一段话可能比较抽象,希望下面的图能有助于你理解,你会发现虽说有不同的含义,但本质还是一样的。

首先是 final 修饰基本数据类型时的内存示意图:

如上图, 变量 a 在初始化后将永远指向 003 这块内存,而这块内存在初始化后将永远保存数值 100。

下面是 final 修饰引用数据类型的示意图:

在上图中,变量 p 指向了 0003 这块内存,0003 内存中保存的是对象 p 的句柄(存放对象p数据的内存地址),这个句柄值是不能被修改的,也就是变量 p 永远指向 p 对象. 但是 p 对象的数据是可以修改的。

// 代码示例
public static void main(String[] args) {
 final Person p = new Person(20, "炭烧生蚝");
 p.setAge(18); //可以修改p对象的数据
 System.out.println(p.getAge()); //输出18

 Person pp = new Person(30, "蚝生烧炭");
 p = pp; //这行代码会报错, 不能通过编译, 因为p经final修饰永远指向上面定义的p对象, 不能指向pp对象.
}

不难看出 final 修饰变量的本质: final 修饰的变量会指向一块固定的内存,这块内存中的值不能改变。

引用类型变量所指向的对象之所以可以修改,是因为引用变量不是直接指向对象的数据,而是指向对象的引用。

所以被 final 修饰的引用类型变量将永远指向一个固定的对象,不能被修改;对象的数据值可以被修改。

2. 进阶:被 final 修饰的常量在编译阶段会被放入常量池中

final 是用于定义常量的,定义常量的好处是:不需要重复地创建相同的变量。

而常量池是 Java 的一项重要技术,由 final 修饰的变量会在编译阶段放入到调用类的常量池中。

请看下面这段演示代码,这个示例是专门为了演示而设计的,希望能方便大家理解这个知识点。

public static void main(String[] args) {
 int n1 = 2019;   //普通变量
 final int n2 = 2019; //final修饰的变量

 String s = "20190522";
 String s1 = n1 + "0522"; //拼接字符串"20190512"
 String s2 = n2 + "0522"; 

 System.out.println(s == s1); //false
 System.out.println(s == s2); //true
}

温馨提示:整数 -127 - 128 是默认加载到常量池里的,也就是说如果涉及到 -127 - 128 的整数操作,默认在编译期就能确定整数的。所以这里我故意选用数字2019 (大于128),避免数字默认就存在常量池中。

上面的代码运作过程是这样的:

首先根据 final 修饰的常量会在编译期放到常量池的原则,n2会在编译期间放到常量池中。

然后 s 变量所对应的”20190522”字符串会放入到字符串常量池中,并对外提供一个引用返回给 s 变量。(下一篇文章会介绍字符串常量池)

这时候拼接字符串 s1,由于 n1 对应的数据没有放入常量池中,所以 s1 暂时无法拼接,需要等程序加载运行时才能确定 s1 对应的值。

但在拼接 s2 的时候,由于 n2 已经存在于常量池,所以可以直接与”0522”拼接,拼接出的结果是”20190522”

这时系统会查看字符串常量池,发现已经存在字符串20190522,所以直接返回20190522的引用。

所以 s2 和 s 指向的是同一个引用,这个引用指向的是字符串常量池中的20190522。

而 n1 会在程序执行时,才有具体的指向。

当拼接 s1 的时候,会创建一个新的 String 类型对象,也就是说字符串常量池中的 20190522 会对外提供一个新的引用。

所以当 s1 与 s 用 “==” 判断时, 由于对应的引用不同, 会返回 false。而 s2 和 s 指向同一个引用,返回true。

这个例子额外说明的是:由于被 final 修饰的常量会在编译期进入常量池,如果有涉及到该常量的操作,很有可能在编译期就已经完成。

3. 探索: 为什么局部/匿名内部类在使用外部局部变量时,只能使用被 final 修饰的变量?

提示: 在JDK1.8以后,通过内部类访问外部局部变量时,无需显式把外部局部变量声明为final。不是说不需要声明为final了,而是这件事情系统在编译期间帮我们做了。 但是我们还是有必要了解为什么要用 final 修饰外部局部变量。

public class Outter {
 public static void main(String[] args) {
  final int a = 10;
  new Thread(){
   @Override
   public void run() {
    System.out.println(a);
   }
  }.start();
 }
}

在上面这段代码, 如果没有给外部局部变量 a 加上 final 关键字,是无法通过编译的。可以试着想想:当 main 方法已经执行完后,main 方法的栈帧将会弹出,如果此时 Thread 对象的生命周期还没有结束,还没有执行打印语句的话,将无法访问到外部的 a 变量。

那么为什么加上 final 关键字就能正常编译呢?

我们通过查看反编译代码看看内部类是怎样调用外部成员变量的。

我们可以先通过 javac 编译得到 .class文件(用IDE编译也可以),然后在命令行输入javap -c .class文件的绝对路径,就能查看 .class 文件的反编译代码。

以上的 Outter 类经过编译产生两个 .class 文件,分别是Outter.class 和 Outter$1.class

也就是说内部类会单独编译成一个.class文件。

下面给出Outter$1.class的反编译代码。

Compiled from "Outter.java"
final class forTest.Outter$1 extends java.lang.Thread {
 forTest.Outter$1();
 Code:
  0: aload_0
  1: invokespecial #1     // Method java/lang/Thread."<init>":()V
  4: return

 public void run();
 Code:
  0: getstatic  #2     // Field java/lang/System.out:Ljava/io/PrintStream;
  3: bipush  10
  5: invokevirtual #3     // Method java/io/PrintStream.println:(I)V
  8: return
}

定位到run()方法反编译代码中的第3行:

3: bipush 10

我们看到 a 的值在内部类的run()方法执行过程中是以压栈的形式存储到本地变量表中的,

也就是说在内部类打印变量 a 的值时,这个变量 a 不是外部的局部变量 a,因为如果是外部局部变量的话,应该会使用load指令加载变量的值。

也就是说系统以拷贝的形式把外部局部变量 a 复制了一个副本到内部类中,内部类有一个变量指向外部变量a所指向的值。

但研究到这里好像和 final 的关系还不是很大,不加 final 似乎也可以拷贝一份变量副本,只不过不能在编译期知道变量的值罢了。这时该思考一个新问题了:

现在我们知道内部类的变量 a 和外部局部变量 a 是两个完全不同的变量,

那么如果在执行 run() 方法的过程中, 内部类中修改了 a 变量所指向的值,就会产生数据不一致问题。

正因为我们的原意是内部类和外部类访问的是同一个a变量,所以当在内部类中使用外部局部变量的时候应该用 final 修饰局部变量,这样局部变量a的值就永远不会改变,也避免了数据不一致问题的发生。

二. final修饰方法
使用 final 修饰方法有两个作用,首要作用是锁定方法,不让任何继承类对其进行修改。

另外一个作用是在编译器对方法进行内联,提升效率。 但是现在已经很少这么使用了,近代的Java版本已经把这部分的优化处理得很好了。

但是为了满足求知欲还是了解一下什么是方法内敛:

方法内敛: 当调用一个方法时,系统需要进行保存现场信息,建立栈帧,恢复线程等操作,这些操作都是相对比较耗时的。

如果使用 final 修饰一个了一个方法 a,在其他调用方法 a 的类进行编译时,方法 a 的代码会直接嵌入到调用 a 的代码块中。

//原代码
public static void test(){
  String s1 = "包夹方法a";
  a();
  String s2 = "包夹方法a";
}

public static final void a(){
  System.out.println("我是方法a中的代码");
  System.out.println("我是方法a中的代码");
}

//经过编译后
public static void test(){
  String s1 = "包夹方法a";
  System.out.println("我是方法a中的代码");
  System.out.println("我是方法a中的代码");
  String s2 = "包夹方法a";
}

在方法非常庞大的时候,这样的内嵌手段是几乎看不到任何性能上的提升的,在最近的 Java 版本中,不需要使用 final 方法进行这些优化了。—《Java编程思想》

三. final 修饰类

使用 final 修饰类的目的简单明确:表明这个类不能被继承。

当程序中有永远不会被继承的类时,可以使用 final 关键字修饰。

被 final 修饰的类所有成员方法都将被隐式修饰为 final 方法。

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对我们的支持。

(0)

相关推荐

  • java关键字final用法知识点

    inal:最终的,确保使用前是被赋值得,一旦赋值后不可修改. 1 数据 ①局部变量 基本数据类型: 可以先定义后赋值,但要保证在使用前是已被赋值的,一旦赋值后不可修改: 引用数据类型: 可以先定义后赋值,但要保证在使用前是已被赋值的,一旦赋值后不可修改: 引用内容不可修改,但备用用的对象内容可以被修改: ②成员变量 必须保证成员变量在使用前被赋值: 成员变量赋值的方式有两种,1声明变量时赋值,2构造函数中赋值: public static void main(String[] args) { /

  • Java中final关键字详解及实例

    final在Java中可以声明成员变量.方法.类以及本地变量.一旦你将引用声明作final,你将不能改变这个引用了,如果你试图将变量再次初始化的话,编译器会报编译错误.  final的含义在不同的场景下有细微的差别,但总体来说,它指的是"不可变". 1. final变量 凡是对成员变量或者本地变量(在方法中的或者代码块中的变量称为本地变量)声明为final的都叫作final变量.final变量经常和static关键字一起使用,作为常量.用final关键字修饰的变量,只能进行一次赋值操作

  • Java关键字final、static使用总结

    一.final 根据程序上下文环境,Java关键字final有"这是无法改变的"或者"终态的"含义,它可以修饰非抽象类.非抽象类成员方法和变量.你可能出于两种理解而需要阻止改变:设计或效率. final类不能被继承,没有子类,final类中的方法默认是final的. final方法不能被子类的方法覆盖,但可以被继承. final成员变量表示常量,只能被赋值一次,赋值后值不再改变. final不能用于修饰构造方法. 注意:父类的private成员方法是不能被子类方法覆

  • Java基础教程之final关键字浅析

    前言 前面在讲解String时提到了final关键字,本文将对final关键字进行解析. static和final是两个我们必须掌握的关键字.不同于其他关键字,他们都有多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构.下面我们来了解一下final关键字及其用法. final从总体上来说是"不可变的",可用于修改类.方法.变量. 一. final类 final修饰的类,该类不能被继承.当你确认一个类永远不会被继承或不想被继承,那么就可以用final修饰. 同样,对于

  • 学习Java的static与final关键字

    static:(静态修饰符)面向对象中static修饰的内容是隶属于类,而不是直接隶属于对象的,所以static修饰的成员变量一般称作类成员变量,而static修饰的方法一般称作类方法. 分类: 1.static变量,也叫作静态变量或者类变量.另一种是没有被static修饰的变量,叫实例变量. 2.static方法,也叫作静态方法或者类方法,静态方法中不能定义静态变量,实例方法也不能. 3.static代码块,静态块中,可以访问静态变量,调用静态方法. 注意事项: 1.static不依附于任何对

  • Java中final关键字的深入探究

    前言 final 关键字的字面意思是最终的,不可修改的.这似乎是一个看见名字就大概知道怎么用的语法,但你是否有深究过final在各个场景中的具体用法,注意事项,以及背后涉及的Java设计思想呢? 一. final 修饰变量 1. 基础: final 修饰基本数据类型变量和引用数据类型变量 相信大家都具备基本的常识: 被 final 修饰的变量是不能够被改变的.但是这里的"不能够被改变"对于不同的数据类型是有不同的含义的. 当 final 修饰的是一个基本数据类型数据时,这个数据的值在初

  • Java中final关键字详解

    谈到final关键字,想必很多人都不陌生,在使用匿名内部类的时候可能会经常用到final关键字.另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法. 主要介绍:一.final关键字的基本用法.二.深入理解final关键字 一.final关键字的基本用法 在Java中,final关键字可以用来修饰类.方法和变量(包括成员变量和局部变量).下面就从这三个方面来了解一下final关键字的基本用法. 1.修饰类 当用final修饰一个类时,表明这个类不能

  • Java中final关键字的使用与注意总结

    前言 在java中可以将实例域定义为final.在构建对象是必须初始化这样的值.必须确保在每个构造器执行之后,这个域的值被设置,并且在后面的操作中不再对其修改.使用final声明变量之后,这个值就不能修改,一般final类型的变量都被声明为静态变量,而且是公有类型的,它在内存中被放在一个特有的公共区域. 也就是说,在Java语法中规定,final修饰的成员变量必须有程序员显式地指定初始值. 定义格式为: public  static  final  double pi = 3.1415926:

  • Java中final关键字和final的4种用法

    目录 1.final 定义 2.final 的 4 种用法 2.1.修饰类 2.2.修饰方法 2.3.修饰变量 2.4.修饰参数 3.final 作用 重要说明:本篇为博主<面试题精选-基础篇>系列中的一篇,查看系列面试文章请关注我. Gitee 开源地址:gitee.com/mydb/interv- 1.final 定义 final 翻译成中文是"最终"的意思,它是 Java 中一个常见关键字,使用 final 修饰的对象不允许修改或替换其原始值或定义. 比如类被 fin

  • java中final关键字使用示例详解

    final经常和static一起使用来声明常量,你也会看到final是如何改善应用性能的.final关键字的含义?final在Java中是一个保留的关键字,可以声明成员变量.方法.类以及本地变量.一旦你将引用声明作final,你将不能改变这个引用了,编译器会检查代码,如果你试图将变量再次初始化的话,编译器会报编译错误.什么是final变量?凡是对成员变量或者本地变量(在方法中的或者代码块中的变量称为本地变量)声明为final的都叫作final变量.final变量经常和static关键字一起使用,

  • Java中final关键字的用法总结

    1.final修饰类 被final修饰的类不能被继承,因此final类的成员方法也不能被覆写,被final关键字修饰的类没有子类,因此类的实现细节也无法改变,无法被扩展.final类中的所有成员方法都会被隐式地指定为final方法,final类中的成员变量可以根据需要设为final. 2.final修饰方法 一个类中的方法如果被final关键字修饰,则其子类无法覆写该方法,只能被子类继承.如果父类中的某个方法不想被其子类所覆写,可将该方法定义为final类型,另外,父类中的私有方法(即被priv

  • 小议Java中final关键字使用时的注意点

    final 类 final 类不能被继承,同时,一旦用 final 修饰了类,也就意味着 final 类中的所有方法都被隐式地指定为 final 方法 final 方法 在类继承的过程中,对于父类中的 final 方法,子类不能修改和覆盖. private 方法都被隐式指定为 final 方法. 有两个原因使用 final 方法: 锁定方法,防止被子类修改其含义 在早期的 java 实现版本中,final 方法被实现为内嵌调用,可以提升性能 final 变量 final 关键字用来修饰变量是最常

  • 举例讲解Java中final关键字的用法

    1. final variable final variable 就是一个常量,一旦被初始化就不可以被改变. class Test1 { final double PI = 3.14; //常量的名称最好大写 public Test1(){ PI = 3.14; } void test(){ System.out.println("PI is: " + PI); } public static void main(String[] args){ Test1 t = new Test1(

  • Java中final,finally,finalize三个关键字的区别_动力节点Java学院整理

    final 当这个关键字修饰一个类时,意味着他不能派生出新的子类,也就是说不能被继承,因此一个类不能被同时声明为abstract和final.当final修饰变量或者方法时,可以保证他们在使用中不会被改变.被声明为final的变量必须在初始化时给定初值,以后在使用时只能被引用而不能被修改.同样,当final修饰一个方法时,这个方法不能被重载. finally 异常处理时提供finally来执行任何清楚操作.如果抛出一个异常,那么相匹配的catch子句就会被执行,然后控制就会转入finally块.

随机推荐