Java基础汇总（三）——final

刘心奶黄包～

已于 2024-08-29 23:23:29 修改

阅读量1.6k

点赞数 3

分类专栏： Java基础知识文章标签： jvm

于 2022-08-06 10:00:00 首次发布

本文链接：https://blog.csdn.net/weixin_45864705/article/details/126184375

版权

Java基础知识专栏收录该内容

23 篇文章 18 订阅

订阅专栏

一、final 变量

定义：

成员变量：在类中，方法外
本地变量(方法内的局部变量)：方法中或者方法声明上(形式参数)

区别：

位置不同：成员变量在类中，方法外；局部变量在方法中或者方法声明上(形式参数)
作用范围不一样：成员变量在类中；局部变量在方法中
生命周期不同：成员变量随着对象的创建而存在，随着对象的消失而消失；局部变量随着方法的调用而存在，随着方法的调用完毕而消失

在类成员中，final经常和static一起使用，作为类常量使用。

类常量必须在声明时初始化，final成员常量可以在构造方法初始化

对于类常量，JVM会缓存在常量池中，调用时不需要类的初始化，所以必须在声明时初始化

例1：类常量必须在声明时初始化

public class Main {
    public static final int i; //报错，必须初始化 因为常量在常量池中就存在了，调用时不需要类的初始化，所以必须在声明时初始化
    public final int j;
    Main() {
        i = 2;
        j = 3;
    }
}

例2：空白final

实例变量：final成员常量可以在构造方法初始化（final一旦被赋值，便不可被更改）

public class FinalTest02(){
    public static void main(String[]args){      
    }
}

class User{
    final int age; // 变量age未在默认构造器中初始化，编译错误
    final int age=10; // 可以编译
    final double weight;
    //构造方法
    public User(){   
        this.weight=80; // 在构造方法中赋值 weight只赋一次值
        this.weight=0; //编译错误，final修饰后，系统不会再次赋值   
    }   
}

实例变量：灵活性增大（一个类中的final数据成员就可以实现依对象而有所不同）

public class FinalTest { 
final int p; 
final int q=3; 

FinalTest(int i){ 

p=i; // 可以赋值，相当于直接定义p 
q=i; // 不能为一个final变量赋值 

} 
}

final+常量：值不能改变，如 final int i=100
final+变量：引用不可被改变,如 final File f=new File("c:\test.txt")，这里的txt文件为只读文件。在这里f一定不能被改变，但却可以想办法将只读文件变为可写文件。即f不能被改变，但可以使用方法改变其中的成员变量，如f想办法将可读文件变为可写文件
形象比喻：一个女子定义了一个final的老公，这个老公的职业和收入都是允许改变的，只是这个女人不会换老公而已。

二、final 方法

不能被子类的方法重写
可以被子类方法重载
父类中private final方法，子类可以重新定义，这种情况不是重写
编译时就已经静态绑定，不需要在运行时动态绑定
final方法调用时使用invokespecial指令

例1：不能被子类的方法重写

class Bi {
    final public void go() {
        //final修饰方法无法被改写
    }
}

class Ci extends Bi {
 @Override
    final public void go() {
             System.out.println("you must go"); // 方法无法被改写
      }
}

例2：被子类方法重载

public class Finaloverload {
	//final 修饰的方法可以重载，参数不同
	public final void test(){}
	public final void test(String arg){}
}

例3：父类中private final方法，子类可以重新定义，这种情况不是重写

public class PrivateFinalMethodTest
{
	private final void test(){} // 定义为private，不能被子类继承
}

class Sub extends PrivateFinalMethodTest
{
    // 没有继承到父类方法，所以相当于子类自己定义了一个全新的方法，所以不会出现问题
	public void test(){} 
}

附：静态方法也不能被重写

例4：

public class Person {

    public static void sleep(){ // 静态方法  不可被重写
        System.out.println("a person need to sleep");
    }
}

class Man extends Person{
    public static void sleep(){
        System.out.println("the man also need to sleep"); // 无法重写
    }

}

三、final方法的好处

性能提高，JVM在常量池中会缓存final变量
final变量在多线程中并发安全，无需额外的同步开销
final方法是静态编译的，提高了调用速度（调用函数需要额外时间去寻找这个函数，final的使用减少函数调用次数就等于降低了性能消耗）
final类创建的对象是只可读的，在多线程可以安全共享

例5：提高速度和效率(编译器直接将func的函数体内嵌到了调用函数的地方，这样的结果是节省了1000次函数调用)

public class Test{ 
final void func(){System.out.println("g");}; 
public void main(String[] args){ 
for(int j=0;j<1000;j++)   
func(); 
}} 


// 经过编译器优化之后，这个类变成了相当于这样写
public class Test{ 
final void func(){System.out.println("g");}; 
public void main(String[] args){ 
for(int j=0;j<1000;j++)  
{System.out.println("g");} 
}}

四、final 类

不能被继承
类中的方法也默认是final类型
java中的String类、Integer类都是final类型

例1：final类不能被继承

final class PersonalLoan{}

class CheapPersonalLoan extends PersonalLoan{  
//编译错误，无法被继承 
}

例2：同final方法中的例1

例3：详见上一篇文章

Java基础汇总（二）——String(重点string.intern())https://mp.csdn.net/mp_blog/creation/editor/126149914例4：

@Test
public final void 修饰类() {

    //final只修饰了Fi类型，即Fi实例化的对象在堆中内存地址是不可变的。
    //虽然内存地址不可变，但是可以对内部的数据做改变。

    Fi f = new Fi(); // 引用没有被final修饰，所以是可变的。
    f.a = 1;
    System.out.println(f);
    f.a = 2;
    System.out.println(f);
    //改变实例中的值并不改变内存地址。

    Fi ff = f;

    //让引用指向新的Fi对象，原来的f对象由新的引用ff持有。
    //引用的指向改变也不会改变原来对象的地址

    f = new Fi();
    System.out.println(f);
    System.out.println(ff);
}

五、final 域的重排序规则

例图代码：

public class FinalExample {
    int i;                            // 普通变量 
    final int j;                      //final 变量 
    static FinalExample obj;

    public void FinalExample () {     // 构造函数 
        i = 1;                        // 写普通域 
        j = 2;                        // 写 final 域 
    }
    
    public static void writer () {    // 写线程 A 执行 
        obj = new FinalExample ();
    }
    
    public static void reader () {       // 读线程 B 执行 
        FinalExample object = obj;       // 读对象引用 
        int a = object.i;                // 读普通域 
        int b = object.j;                // 读 final 域 
    }
}

写 final 域的重排序规则

JMM 禁止编译器把 final 域的写重排序到构造函数之外。
编译器会在 final 域的写之后，构造函数 return 之前，插入一个 StoreStore 屏障。这个屏障禁止处理器把 final 域的写重排序到构造函数之外

例图：

读final 域的重排序规则

在一个线程中，初次读对象引用与初次读该对象包含的 final 域，JMM 禁止处理器重排序这两个操作（注意，这个规则仅仅针对处理器）。编译器会在读 final 域操作的前面插入一个 LoadLoad 屏障。即在读一个对象的 final 域之前，一定会先读包含这个 final 域的对象的引用。

例图：