Java中的 final关键字

final 关键字

1. final 的基本概念

• 基本介绍：
  
• 代码演示：

public class Final01 {
    public static void main(String[] args) {
        E e = new E();
        //e.TAX_RATE = 0.09; 错误，属性TAX_RATE 不能被修改
    }
}

// （1）如果我们要求A类不能被其他类继承，可以使用final修饰 A类
final class A { }

//class B extends A {} 错误，A类不能被继承；

class C {
    //如果我们要求 hi 方法不能被子类重写，可以使用 final修饰 hi方法
    public final void hi() {}
}

class D extends C {

/* 错误，hi 方法不能被重写
   @Override
   public void hi() {
       System.out.println("重写了C类的hi方法..");
   }*/
}

//当不希望类的的某个属性的值被修改,可以用final 修饰
class E {
	// TAX_RATE 属性也被称为常量；
    public final double TAX_RATE = 0.08;
}

//当不希望某个局部变量被修改，可以使用final修饰
class F {
    public void cry() {
        // 这时，NUM 也称为 局部常量；
        final double NUM = 0.01;
        // NUM = 0.9; 错误，NUM 不能被修改
        System.out.println("NUM=" + NUM);
    }
}

2. final 使用注意事项和细节

• 注意事项和细节：

（1）final 修饰的属性又叫常量，一般用 XX_XX_XX 来命名。

（2）final 修饰的属性在定义时，必须赋初值，并且赋值后不能更改，赋值操作可以在以下位置（选择一个就行）。

• 在定义属性时：如 public final double TAX_RATE = 0.08;
• 在构造器中；
• 在代码块中（静态代码块或者普通代码块）；

（3）若 final 修饰的属性同时被 static 修饰，则初始化的位置只能是以下位置（选择一个就行）。

• 在定义属性时：如 public final static double TAX_RATE = 0.08;
• 在静态代码块中（不能在普通代码块和构造器中赋值）；

（4）final 类不能被继承，但是可以创建该类的对象。

（5）如果类没有被 final 修饰，但是含有 final 方法，则虽然该方法不能被子类重写，但是可以被子类继承。

• 代码演示：

public class FinalDetail01 {
    public static void main(String[] args) {
        CC cc = new CC();// 创建 final 修饰的CC类的对象

        new EE().cal();// EE类可以使用 DD类中的 fanal 方法
    }
}

class AA {
    /*
    （1）在定义属性时：如 public final double TAX_RATE = 0.08;
    （2）在构造器中；
    （3）在代码块中（静态代码块或者普通代码块）；
     */
    public final double TAX_RATE = 0.08;//1.定义时赋值
    public final double TAX_RATE2 ;
    public final double TAX_RATE3 ;

    // 在构造器中赋值
    public AA() {
        TAX_RATE2 = 1.1;
    }

    // 在代码块中赋值
    {
        TAX_RATE3 = 8.8;
    }
}

class BB {
    /*
    如果final修饰的属性是静态的，则初始化的位置只能是
    （1）在定义属性时；
    （2）在静态代码块中（不能在普通代码块和构造器中赋值）；
     */
    public static final double TAX_RATE = 99.9;//1.定义时赋值
    public static final double TAX_RATE2 ;

    // 在静态代码块中赋值
    static {
        TAX_RATE2 = 3.3;
    }
}

//final类不能继承，但是可以实例化对象
final class CC {}

//如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承
//即，仍然遵守继承的机制.
class DD {
    public final void cal() {
        System.out.println("cal()方法");
    }
}

class EE extends DD {}

（6）一般来说，如果一个类已经是 final 类了，就没有必要再将该类的方法修饰成 final 方法；因为final 类不能被继承，自然该类中的方法就不会被重写。

（7）final 类不能修饰构造器。

（8）final 和 static 往往一起搭配使用，效率更高；底层的编译器做了优化，使用两者结一起修饰的属性，在使用时不会导致类的加载，节约了资源。

（9）包装类（Integer、Double、Float…）和String 类都是 final 类，不能被继承。

• 代码演示：

public class FinalDetail02 {
    public static void main(String[] args) {
        
        // 不会输出静态代码块的内容，因为BBB 类没有被加载
        System.out.println(BBB.num);

        //包装类、String 都是 final 类，不能被继承；

    }
}

// final 和 static 往往一起搭配使用，效率更高；
// 底层的编译器做了优化，使用两者结一起修饰的属性，在使用时不会导致类的加载，节约了资源。
class BBB {
    // 在调用静态属性 num时，若是只有static 修饰，则会加载整个BBB 类，
    // 但加上 final一起修饰后，则不会加载BBB 类
    public final static  int num = 10000;
    
    static {
        System.out.println("BBB 静态代码块被执行");
    }
}

final class AAA{
    // 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法
    // public final void cry() {}
}

总结

• 本文是小白博主在学习B站韩顺平老师的Java网课时整理总结的学习笔记，在这里感谢韩顺平老师的网课，如有有兴趣的小伙伴也可以去看看。
• 本文详细解释了 final 关键字的概念与使用，并深入介绍了使用 final 的注意事项和细节，希望小伙伴们看后能有所收获！
• 最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！我们下一篇博文见吧！