Java中的 final关键字

不念不忘少年蓝@ 2024-04-26 10:45 42阅读 0赞

## final 关键字 ##

### 1. final 的基本概念 ###

*  **基本介绍：**  
    ![在这里插入图片描述][51020cde1b4d4cb2ace7e61897bdb20e.png]
 *  **代码演示：**

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 的注意事项和细节，希望小伙伴们看后能有所收获！
 *  最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！我们下一篇博文见吧！

[51020cde1b4d4cb2ace7e61897bdb20e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8acfa71e89714e2e8e226f60d7277b9e.png