final&static在java中的具体表现

最新推荐文章于 2024-09-12 11:08:51 发布
最新推荐文章于 2024-09-12 11:08:51 发布
阅读量241 收藏
点赞数
文章标签： java 内存 栈 对象 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/n05081526/article/details/77485382
版权

final的目的是为了某些数据不要改变，减轻系统负担。

final可以修饰数据，方法，类。


一、数据

package test;

import java.util.Random;

public class FinalTest {
        private final String final_01 = "jason";    //编译期常量，必须要进行初始化，且不可更改
        private final String final_02;         //构造器常量，在实例化一个对象时被初始化
        
        private static Random random = new Random();
        private final int final_03 = random.nextInt(10); //使用随机数来进行初始化
        
        //引用变量
        public final Person final_04 = new Person("jason_nan"); //final指向引用数据类型
        
        FinalTest(String final_02){
            this.final_02 = final_02;
        }
        
        public String toString(){
            return "final_01 = " + final_01 +"   final_02 = " + final_02 + "   final_03 = " + final_03 +
                   "   final_04 = " + final_04.getName();
        }
        
        public static void main(String[] args) {
            System.out.println("------------第一次创建对象------------");
            FinalTest final1 = new FinalTest("cm");
            System.out.println(final1);
            System.out.println("------------第二次创建对象------------");
            FinalTest final2 = new FinalTest("zj");
            System.out.println(final2);
            System.out.println("------------修改引用对象--------------");
            final2.final_04.setName("jasonnan");
            System.out.println(final2);
        }
    
}
    class Person {
    private String name;

    Person(String name){
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

输出结果：

------------第一次创建对象------------
final_01 = jason   final_02 = cm   final_03 = 0   final_04 = jason_nan
------------第二次创建对象------------
final_01 = jason   final_02 = zj   final_03 = 6   final_04 = jason_nan
------------修改引用对象--------------
final_01 = jason   final_02 = zj   final_03 = 6   final_04 = jasonnan
注：这里类重写了toString方法，引用变量根据toString输出已不是内存地址。

       1.private final String final_01 = "jason"；//这里是在编译期就在线程私有栈中分配给final_01一个固定空间位置，指向的是String类型在方法区常量池中唯一的存有“jason”字符串的地址，final_01已经无法被重新赋值，也就是说这一状态一直持续到该线程结束。

       2.private final String final_02;//这里指编译期就在线程私有栈中分配给final_02一个固定空间位置，并没有指向对象地址，而需要在运行初始化期间，指向String类型在方法区常量池中唯一的存有“null”字符串的地址，这一状态可以在重新被赋值会有所改变，但引用变量在私有栈中的位置一直不变，指向的常量可以改变，这就是编译期赋值与运行期赋值的差别。final变量在定义的时候，可以先声明，而不给初值，这种变量也称为final空白，无论什么情况。编译器都确保空白final在使用之前必须被初始化，直接操作就是根据数据类型赋值，String为null,int为0等，因此final数据成员会依据不同对象而有所不同。

       3.private final int final_03 = random.nextInt(10); //这里指编译期就在线程私有栈中分配给final_03一个固定空间位置，然后在初始化时（这里的初始化指的是依附的类实例化对象）调用random.nextInt(10)得到一个int值，在线程私有栈中分配空间，由于是随机数，栈中空间也是不固定的，这里FinalTest类实例化了两次，final_03也是不同的，这说明创建一个实例对象，final_03就初始化一次。

       4.public final Person final_04 = new Person("jason_nan");///这里指编译期就在线程私有栈中分配给final_03一个固定空间位置，然后在初始化时在堆的空间创建了一个Person("jason_nan")实例化对象，这里初始化了两次，也就是说在堆空间中有两个Person("jason_nan")实例化对象，具体是不是这样，下面我们修改一下代码：

       

package test;

import java.util.Random;

public class FinalTest {
	    private final String final_01 = "jason";    //编译期常量，必须要进行初始化，且不可更改
	    private final String final_02;                //构造器常量，在实例化一个对象时被初始化
	    
	    private static Random random = new Random();
	    
	     private final  int final_03 = random.nextInt(10);    //使用随机数来进行初始化
	    //引用
	    public final Person final_04 = new Person("jason_nan");    //final指向引用数据类型
	    
	    FinalTest(String final_02){
	        this.final_02 = final_02;
	    }
   
	    
	 public String toString(){
	       return "final_01 = " + final_01 +"   final_02 = " + final_02 + "   final_03 = " + final_03 +
	             "   final_04 = " + final_04.getName();
	   }
	    
	    public static void main(String[] args) {
	    	
	        System.out.println("------------第一次创建对象------------");
	        FinalTest final1 = new FinalTest("cm");
	     	System.out.println(final1.final_04);
	        System.out.println(final1);
	        System.out.println("------------第二次创建对象------------");
	        FinalTest final2 = new FinalTest("zj");
	      	System.out.println(final1.final_04);
	        System.out.println(final2);
	        System.out.println("------------修改引用对象--------------");
	        final2.final_04.setName("jasonnan");
	        System.out.println(final2);
	    }
	
}
    class Person {
    private String name;

    Person(String name){
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

结果：

------------第一次创建对象------------
test.Person@1f33675
final_01 = jason   final_02 = cm   final_03 = 2   final_04 = jason_nan
------------第二次创建对象------------
test.Person@1f33675
final_01 = jason   final_02 = zj   final_03 = 3   final_04 = jason_nan
------------修改引用对象--------------
final_01 = jason   final_02 = zj   final_03 = 3   final_04 = jasonnan

返回的两次

System.out.println(final1.final_04);
结果均是一样的。而且不管我怎么重复运行程序，结果还是这个地址。 这说明不管多少次创建实例对象（初始化），一旦一个对象引用被修饰为final后，它只能恒定指向一个对象，无法将其改变为另一个对象，也就是堆地址不变，而堆里面的内容可以改变。

一个既是static又是final的字段只占据一段不能改变的存储空间：

package test;

import java.util.Random;

public class FinalTest {
	    private final String final_01 = "jason";    //编译期常量，必须要进行初始化，且不可更改
	    private final String final_02;                //构造器常量，在实例化一个对象时被初始化
	    
	    private static Random random = new Random();
	    private static final  int final_03 = random.nextInt(10);    //使用随机数来进行初始化
	    //引用
	    public final Person final_04 = new Person("jason_nan");    //final指向引用数据类型
	    
	    FinalTest(String final_02){
	        this.final_02 = final_02;
	    }
   
	    
	 public String toString(){
	       return "final_01 = " + final_01 +"   final_02 = " + final_02 + "   final_03 = " + final_03 +
	             "   final_04 = " + final_04.getName();
	   }
	    
	    public static void main(String[] args) {
	    	
	        System.out.println("------------第一次创建对象------------");
	        FinalTest final1 = new FinalTest("cm");
	     	//System.out.println(final1.final_04);
	        System.out.println(final1);
	        System.out.println("------------第二次创建对象------------");
	        FinalTest final2 = new FinalTest("zj");
	      	//System.out.println(final1.final_04);
	        System.out.println(final2);
	        System.out.println("------------修改引用对象--------------");
	        final2.final_04.setName("jasonnan");
	        System.out.println(final2);
	    }
	
}
    class Person {
    private String name;

    Person(String name){
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

这段代码我在只是修改了private static final  int final_03 = random.nextInt(10);

这样的结果为：

------------第一次创建对象------------
final_01 = jason   final_02 = cm   final_03 = 4   final_04 = jason_nan
------------第二次创建对象------------
final_01 = jason   final_02 = zj   final_03 = 4   final_04 = jason_nan
------------修改引用对象--------------
final_01 = jason   final_02 = zj   final_03 = 4   final_04 = jasonnan

这说明第一次初始化时也就是 FinalTest final1 = new FinalTest("cm");实例化时，如果只有 final 修饰 则final_03指向线程私有栈的字面值为4的空间，如果是static final组合修饰，则专门在内存中开劈一个空间给final_03来储存random.nextInt(10)的结果，在第二次初始化时（FinalTest final2 = new FinalTest("zj");），random.nextInt(10)的值可能是7，如果只有 final 修饰 则final_03指向线程私有栈的字面值为7的空间，（在栈中的指向与指向堆是不一样的，栈是一个一个对象塞进去，等要用的时候再从最上层开始一个一个取出来，这里需要知道栈是如何运作的），如果是static final组合修饰，则直接向已开辟的指定内存空间取出值，这个值在第一次赋值后就不会改变，这是针对基本数据类型的，但static final组合修饰时如果是在栈中的对象，不能改变的是对象的类名，但由于类的封装，就是高内聚，低耦合，内部的属性和方法是可以改变的，只是说外表还是这个人，但他可以慢慢跑，也可以快步跑。实例化后的对象也可以有各种不同的实际状态，每一个时间段也可以有不同的状态。

再来如下修改一下代码看看：

package test;

import java.util.Random;

public class FinalTest {
	    private final String final_01 = "jason";    //编译期常量，必须要进行初始化，且不可更改
	    private final String final_02;                //构造器常量，在实例化一个对象时被初始化
	    
	    private static Random random = new Random();
	    private static final  int final_03 = random.nextInt(10);    //使用随机数来进行初始化
	    //引用
	    public static final Person final_04 = new Person("jason_nan");    //final指向引用数据类型
	    
	    FinalTest(String final_02){
	        this.final_02 = final_02;
	    }
   
	    
	 public String toString(){
	       return "final_01 = " + final_01 +"   final_02 = " + final_02 + "   final_03 = " + final_03 +
	             "   final_04 = " + final_04.getName();
	   }
	    
	    public static void main(String[] args) {
	    	
	        System.out.println("------------第一次创建对象------------");
	        FinalTest final1 = new FinalTest("cm");
	     	//System.out.println(final1.final_04);
	        System.out.println(final1);
	        System.out.println("------------第二次创建对象------------");
	        FinalTest final2 = new FinalTest("zj");
	      	//System.out.println(final1.final_04);
	        System.out.println(final2);
	        System.out.println("------------修改引用对象--------------");
	        final2.final_04.setName("jasonnan");
	        System.out.println(final2);
	    }
	
}
    class Person {
    private String name;

    Person(String name){
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

结果为：

------------第一次创建对象------------
final_01 = jason   final_02 = cm   final_03 = 9   final_04 = jason_nan
------------第二次创建对象------------
final_01 = jason   final_02 = zj   final_03 = 9   final_04 = jason_nan
------------修改引用对象--------------
final_01 = jason   final_02 = zj   final_03 = 9   final_04 = jasonnan


这里修改的是 public static final Person final_04 = new Person("jason_nan");

但结果与没有static一样，这是由于在堆中的对象可以有不同的状态，根据类的封装，就是高内聚，低耦合，内部的属性和方法是可以改变的，只是说外表还是这个人，但他可以慢慢跑，也可以快步跑。实例化后的对象也可以有各种不同的实际状态，每一个时间段也可以有不同的状态。而对于static final来说，第一次初始化后，引用变量的地址，对象的地址，对象均是没有变化的，而对于final来说，第一次初始化后，引用变量的地址，对象的地址，均没有变，但对象空间里的对象可以换成其他类。


n05081526
关注
java多线程关键字final和static详解
08-25
在本文中，我们将深入探讨final和static关键字在Java多线程编程中的应用和特点。 一、final关键字 final关键字是Java语言中的一种修饰符，用于修饰变量、方法和类。final关键字的主要特点是：一旦被赋值后就不能被...
UML 类图各符号含义速查
COFACTOR
07-06 3373
链接：https://pan.baidu.com/s/1RePYipe_4hnW_EtCbD-r9Q 提取码：0000 概述 类图 类名 访问修饰符 变量名 : 返回类型（例：+ Username : String） 访问修饰符 方法名 () : 返回类型（例：+ getUsername () : String） static成员所在的行要加下划线；final成员所在的行末要标识“{readonly}”。 abstract方法要用斜体表示。 属性 方法 Java / C#访问修饰符 Java publ
【java】UML类图与常见类关系图
qq_51639352的博客
10-25 3147
【java】UML类图与常见类关系 由于吕大爷十分在意类关系的绘制，但是我又没有学明白这个东西，就打算自己整理一下。又由于某人说百香果果茶不好喝，我直接is-a sb泛化关系警告！！！ 感谢上述两人对本博客的动力赞助，感觉很好，下次不需要了。 一、UML图 UML图属于结构图，常被用于描述一个系统的静态结构。在一个UML中通常包含类的UM图、接口的UML图、泛化关系的UML图、关联关系的UML图、依赖关系的UML图和实现关系的UML图。 在类的UML图中，使用一个长方形描述一个类的主要构成，将长方形垂直的分
Java中this，static，final，const用法详解
08-25
在 Java 编程语言中，这、static、final 和 const 是四个非常重要的关键字，每个关键字都有其特定的用法和应用场景。下面我们将详细介绍每个关键字的用法和特点。 一、this关键字 this 关键字是 Java 中的一个特殊...
浅析对Java关键字final和static的理解
08-30
在Java编程语言中，`final`和`static`是两个非常重要的关键字，它们分别用于定义不同类型的特性。下面我们将深入探讨这两个关键字的含义和用法。 首先，`final`关键字在Java中具有三个主要用途：修饰类、方法和变量...
Java关键字final、static使用总结
08-30
Java中的final和static是两个非常重要的关键字，它们在编程中有着特定的作用和用途。 首先，final关键字用于声明不可变的对象、方法或类。当我们说一个东西是final时，意味着它不能被修改或重写。 1. **final类**...
详解Java中final的用法
09-03
总结来说，`final`关键字在Java中的应用主要有以下几个好处： 1. 提高程序安全性：通过限制类的继承和方法的覆盖，可以防止意外的改动，保证代码的稳定性。 2. 提升代码可维护性：使用`final`常量可以避免在代码中多...
spring事务详细讲解-深入浅出
小电玩
09-08 501
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1486
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
yang_brother的博客
09-10 553
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
基于SpringBoot的旅游管理系统
heye0910032的博客
09-08 481
随着科技的发展，旅游管理系统的信息化成为提升旅游服务效率的关键。本系统采用JSP技术和SpringBoot框架，结合MySQL数据库，旨在实现一个功能全面、操作简便、安全可靠的旅游管理平台。系统通过需求分析、系统设计、功能实现和测试，确保了良好的用户体验和数据处理能力，为旅游业务的现代化管理提供了强有力的技术支持。本研究成功开发了一个基于SpringBoot的旅游管理系统，该系统通过集成多种旅游管理功能，显著提高了旅游服务的效率和质量。系统的用户友好界面和强大的后端功能，使得管理员和用户都能从中受益。
自定义Stater
m0_63624484的博客
09-07 739
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 589
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
MyBatis面试
Tony_yitao的博客
09-09 753
MyBatis面试
Linux服务器Java启动脚本
Jack魏
09-08 561
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 349
步骤很详细，直接上教程……
Springboot废品回收系统---附源码86799
weixin_BYSJ1987的博客
09-07 1308
在系统的设计与实现中，本论文主要包括以下几个方面：首先，设计了系统的功能模块，包括用户注册登录、商品信息发布、回收订单管理等；其次，利用SpringBoot的特性，搭建了系统的后端框架，并实现了相应的业务逻辑；最后，使用前端技术，设计了用户友好的界面，使用户可以方便地使用系统。
C#基础（11）函数重载
最新发布
a6s686的博客
09-12 514
我们通过这些例子的学习，想毕你一定已经掌握了函数重载的相关内容，我相信你只要稍加练习，便能达到很熟练的程度。不过不管知识点难或者简单，还是那句话，学习路上，戒骄戒躁，脚踏实地。请期待我的下一篇博客！
SpringBoot总结
2302_77073236的博客
09-06 313
都做成图了，方便理解和掌握全局关系。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值