final的几个注意点讲解(作者亲测)

最新推荐文章于 2022-11-07 17:58:18 发布
最新推荐文章于 2022-11-07 17:58:18 发布
阅读量504 收藏
点赞数
分类专栏： 数据结构 java 文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gg1229505432/article/details/122607493
版权

首先我们测试final对非静态变量和方法的影响

有final的情况下:

public class FinalTest {
    final int a = 1;
    final String s = "sss";
    final void haha() {
        System.out.println("haha");
        System.out.println(a);
    }
    public static void main(String[] args) {
        FinalTest finalTest = new FinalTest();
    }
}

反编译字节码文件:

public class com.heaboy.mvc.FinalTest {
  final int a;

  final java.lang.String s;

  public com.heaboy.mvc.FinalTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_1
       6: putfield      #2                  // Field a:I
       9: aload_0
      10: ldc           #3                  // String sss
      12: putfield      #4                  // Field s:Ljava/lang/String;
      15: return

  final void haha();
    Code:
       0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #6                  // String haha
       5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      11: iconst_1
      12: invokevirtual #9                  // Method java/io/PrintStream.println:(I)V
      15: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #8                  // class com/heaboy/mvc/FinalTest
       3: dup
       4: invokespecial #10                 // Method "<init>":()V
       7: astore_1
       8: return
}

无final的情况下:

public class FinalTest {
    int a = 1;
    String s = "sss";
    void haha() {
        System.out.println("haha");
        System.out.println(a);
    }
    public static void main(String[] args) {
        FinalTest finalTest = new FinalTest();
    }
}

反编译字节码文件:

public class com.heaboy.mvc.FinalTest {
  int a;

  java.lang.String s;

  public com.heaboy.mvc.FinalTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_1
       6: putfield      #2                  // Field a:I
       9: aload_0
      10: ldc           #3                  // String sss
      12: putfield      #4                  // Field s:Ljava/lang/String;
      15: return

  void haha();
    Code:
       0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #6                  // String haha
       5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      11: aload_0
      12: getfield      #2                  // Field a:I
      15: invokevirtual #8                  // Method java/io/PrintStream.println:(I)V
      18: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #9                  // class com/heaboy/mvc/FinalTest
       3: dup
       4: invokespecial #10                 // Method "<init>":()V
       7: astore_1
       8: return
}

综上所得,final在两者在haha()方法中有一点点的不同:

  • 我们这里输出的是a:

    • 没有final修饰的变量a,我们需要aload_0,getfield,即加载变量,获取变量的值,然后输出

    • 有final修饰的变量a,我们只需要装载iconst_1或者sipush(这个是大数,比如我们给a刚开始的赋值为10,这就是大数,jvm就不会使用iconst_1,而是选择去用sipush去执行赋值的操作),即直接加载常量,直接输出
    • 理论上有final修饰出的常量调用更快一点

之后我们测试final对静态变量和方法的影响

有final的情况下:

public class FinalTest {
    final static int a = 1;
    final static String s = "sss";
    final static void haha() {
        System.out.println(a);
    }
    public static void main(String[] args) {
        FinalTest finalTest = new FinalTest();
    }
}

反编译字节码文件:

public class com.heaboy.mvc.FinalTest {
  static final int a;

  static final java.lang.String s;

  public com.heaboy.mvc.FinalTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  static final void haha();
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: iconst_1
       4: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
       7: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #3                  // class com/heaboy/mvc/FinalTest
       3: dup
       4: invokespecial #5                  // Method "<init>":()V
       7: astore_1
       8: return
}

没有final的情况下:

public class FinalTest {
    static int a = 1;
    static String s = "sss";
    static void haha() {
        System.out.println(a);
    }
    public static void main(String[] args) {
        FinalTest finalTest = new FinalTest();
    }
}

反编译字节码文件:

public class com.heaboy.mvc.FinalTest {
  static int a;

  static java.lang.String s;

  public com.heaboy.mvc.FinalTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  static void haha();
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: getstatic     #3                  // Field a:I
       6: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
       9: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #5                  // class com/heaboy/mvc/FinalTest
       3: dup
       4: invokespecial #6                  // Method "<init>":()V
       7: astore_1
       8: return

  static {};
    Code:
       0: iconst_1
       1: putstatic     #3                  // Field a:I
       4: ldc           #7                  // String sss
       6: putstatic     #8                  // Field s:Ljava/lang/String;
       9: return
}

综上所得,final修饰的变量有不同,两者在haha()方法中也有一点点的不同:

  • final修饰的变量不在静态区当中,而是常量池中

  • 我们这里输出的是a:

    • 没有final修饰的变量a,我们需要getstatic,即加载静态变量,然后输出

    • 有final修饰的变量a,我们只需要装载iconst_1或者sipush即直接加载常量,直接输出

父子继承问题

  1. final修饰的类不能被继承
  2. final修饰的对象和数组,我们是可以修改里面的内容的,但是不能修改地址
  3. 我们不能给父类的变量重新赋值,并且不能重写父类的方法

我们测试第一种情况:会报错,不能继承final修饰的类

public class FinalTest extends FinalDadTest {
    
}

final class FinalDadTest {

}

 

我们测试第二种情况会输出1111:我们可以得出,final修饰的对象和数组,我们是可以修改里面的内容的,但是不能修改地址

public class FinalTest extends FinalDadTest {
    public static void main(String[] args) {
        final FinalTest finalTest = new FinalTest();
        final int[] arr = finalTest.arr;
        arr[0] = 1111;
        System.out.println(arr[0]);// 输出1111
    }
}

class FinalDadTest {
    final int a = 1;
    final int[] arr = new int[10];
    final void haha() {
        System.out.println("sss");
    }
    final void cece() {
        System.out.println("cece");
    }
}


 

我们测试第三种情况:我们会发现我们不能给父类的a重新赋值,并且不能重写父类的方法haha().

public class FinalTest extends FinalDadTest {
    public FinalTest() {
        super.a = 2;
    }
    void haha() {
        System.out.println(a);
    }
    public static void main(String[] args) {
    }
}

class FinalDadTest {
    final int a = 1;
    final void haha() {
        System.out.println("sss");
    }
}

终

一位即将成功的野男人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【java】final关键字
刘亚男
07-06 320
可以用来修饰一个类 格式： public final class 类名称() PS: 1.当前这个类不能有任何的子类（任何一个类都有一个父类，即使没有写“extends”，也会有一个默认的object类（父类）） 2.其中所有的成员方法都无法进行覆盖重写（因为不能有子类） 可以用来修饰一个方法 格式： 修饰符 final 返回值类型 方法名称（参数类表）{ 方法体 } PS: 1...
final关键字
qq_65231448的博客
08-01 110
下面代码给了赋值方式，需要注意的是：在构造方法中为实例常量赋值，必须保证所有的构造方法都能对其正确赋值。final修饰类 ：此类不能被继承（String Math System均为final修饰的类，不能被继承）nums= new int[5];final可修饰的内容：1.类（最终类） 2.方法（最终方法） 3.变量（最终变量）final修饰变量，此变量值不能被改变，所有final修饰的变量只能赋值一次，值不允许改变。静态常量，不再提供默认值，需要手动赋值，代码中给了赋值的方法，任选其一。.....
final 关键字
weiaini3039的博客
03-18 100
classpublic class ClassA { //指定成员的默认值 String name="defualt"; int n=100; //无参 但有默认值 的构造方法 //  使得创建出的实例有一些默认值// public ClassA() {// super();// this.name = "defualt";// this.n = 100;// } }finalstudyp...
Java | 关于final修饰变量的认识补充
黄佳俊的博客
08-29 880
一、概述 final 最终的 不能改变的。 final 修饰一个变量，有很多种说法，比如不能改变等等 准确的描述是 当一个变量被final修饰的时候，该变量只有一次赋值的机会 不能改变的是变量空间里面存的值或者引用地址。 在栈内存中 final int a = 1;这种赋值后是不能再改的。 final int[] a = {1,2,3} 这种栈里a变量空间存放的是堆内存的地址。地址是不可变的，但是数组里的值是可以变 二、代码示例 情况一：申明时已赋值 public class
final修饰符：
weixin_30394251的博客
12-19 296
知识点： 1、final关键字用于修饰类、变量和方法 2、有点类似C#里的 sealed 关键字，用于表示它修饰的方法、变量和类不可以再被改变 3、final修饰变量时，表示该变量一旦获取了初始值，就不可以再被改变 4、final可以修饰成员变量（包括类变量、实例变量），也可修饰局部变量、形参 5、有的书上说final修饰的变量不能被赋值，这是错误的，严格的说，fanal修饰的变量，一旦...
一个检测表单数据的JavaScript实例
10-25
在给出的代码中，主要涉及以下几个 JavaScript 函数： 1. `validateField`：这个函数用于验证名为 "thirdfield" 的输入字段。它检查用户输入是否为数字。如果输入的是非数字值，如 "abc" 或 "123abc"，则会调用 `...
OFDM_Final_Report(含代码).rar
09-06
OFDM的工作原理可以分为以下几个关键部分： 1. **频域编码**：首先，高数据速率的信息流被转换为多个较低速率的数据流。这个过程通常通过使用IFFT（快速傅里叶逆变换）来实现，它将时域信号转换为频域信号。 2. **...
final关键字和static_用法
11-25
`final`变量可以分为以下几类： - **静态变量**：即类级别的常量，如`public static final int C = 80;`。 - **实例变量**：每个对象的副本都有各自的值，如`private final String S = "final实例变量S";`。 - **...
单例模式讲解
02-24
单例模式确保一个类仅有一个实例存在，并提供一个全局访问点来获取该实例。这种模式通常用于资源管理、线程池、日志对象、数据库连接等场景。 单例模式的特点总结如下： 1. **单例类只能有一个实例**：这是单例...
javaee讲解.pdf
09-30
本文将详细讲解Java EE中的几个关键概念和技术。 首先，我们来看看JVM加载类的机制。Java虚拟机（JVM）在运行Java程序时，会通过类装载器（ClassLoader）来加载类的字节码文件。这个过程分为四个步骤：装载、链接、...
JavaSE——final关键字与常量
最新发布
weixin_51351637的博客
11-07 624
final修饰的实例变量一般添加static修饰，联合修饰的变量称为常量 常量名建议全部大写，每个单词之间采用下划线连接 常量和静态变量都存储在方法区，并且都是在类加载时初始化 因为final修饰的实例变量一旦改变之后便不可更改，这样的话当我们new100个对象时，这个final修饰的实例变量全是一模一样的，这样很占用内存，不如与static共同修饰实例变量
Java学习笔记——修饰符
D77的博客
04-28 780
Java的修饰符分为两大类：访问修饰符、非访问修饰符 一、访问修饰符 1、default:默认访问权限；只对同一个包可见（同包、同类）； 2、private：私有访问；只对同一个类可见（同类）； 3、public：共有访问；对所有的类可见（同包、同类、子类、其他包）； 4、protected：保护性访问；对同一个包可见（同包、同类、子类）； 二、非访问修饰符 1、static:创建类方法和类变量； a.static 成员变量 static成员变量 = static + 成员变量，sta
Variable used in lambda expression should be final or effectively final
热门推荐
技术分享，读书笔记，面试宝典，算法积累，应有尽有～
09-06 14万+
我们在使用 Java8 lambda 表达式的时候常常会遇到这样的编译报错 Variable used in lambda expression should be final or effectively final
(七)：final与static final变量(原生类型)的初始化方式
lukuijun1981的专栏
02-27 681
[code="java"]public class FinalOriginalTest { private final int a; private String name; public FinalOriginalTest(){ a = 3; } public FinalOriginalTest(String name){ this.name = name; ...
你知道Java中final和static修饰的变量是在什么时候赋值的吗？
CoderW
12-19 3230
深入底层了解类变量
关于final修饰符你不知道的事
每天进步一点点...
05-26 2428
你可能知道： final可以修饰变量，并在赋予初值后，不可以再改变 final可以修饰方法，该方法不能被重写 final可以修饰类，该类不能派生子类 但你是否知道以下关于final的其他重要知识？ 1. final修饰实例变量： final修饰的实例变量必须显式地指定初始值，而且该初始值只能在以下3个位置指定： (1)定义时直接指定 比如：final int a=5； (
java final关键字引起的问题
RSun
11-12 658
final 关键字问题，最近发布项目掉进了final坑里面，可怜俺对编译原理不慎熟悉，严重自卑中，下定决心从JAVA基础学起！ 项目发布在linux下，更改了final声明类的方法，然后直接给此类copy到了服务器上，结果项目运行到类中的方法总是报错，最后还是一位同事的提示下才发现问题。 说明：类或常量字段声明final之后，如果更改此类或常量的值，则引用过此类的方法或此常量的类文件都需要重新
面向对象_final修饰变量的初始化时机
辐_射的博客
10-04 2166
/* final修饰变量初始化时机 A:被final修饰的值只能赋值一次 B:在构造方法完毕前。(非静态的常量) */ class Demo{ //int num = 10; //final int num2 = 20; int num; final int num2; { //num2 = 10; } public Demo(){ num = 100;
深入解析Java多线程final关键字详解与应用
本文主要分为以下几个部分： 1. **基础用法与面试问题关联**： - 通过BAT大厂面试问题的角度来剖析`final`，帮助读者更好地理解和记忆其概念。 2. **final的基础使用**： - **修饰类**: 当一个类被声明为`final`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值