非零基础自学Java (老师：韩顺平) 第10章 面向对象编程(高级部分) 10.5 final关键字

非零基础自学Java (老师：韩顺平)

✈【【零基础 快速学Java】韩顺平 零基础30天学会Java】

第10章 面向对象编程(高级部分)

10.5 final关键字

10.5.1 基本介绍

final中文意思：最后的、最终的

final可以修饰类、属性、方法和局部变量。

在某些情况下,程序员可能有以下需求，就会使用到final:

• 当不希望类被继承时,可以用final修饰.
• 当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰。
• 当不希望类的的某个属性的值被修改,可以用final修饰.
• 当不希望某个局部变量被修改，可以使用final修饰

举个栗子

package com.dingjiaxiong.final_;

/**
 * ClassName: Final01
 * date: 2022/9/3 19:35
 *
 * @author DingJiaxiong
 */

public class Final01 {
    public static void main(String[] args) {
        E e = new E();
//        e.TAX_RATE = 0.09; //报错
    }
}

final class A{} //要求A不能被其他类继承

//class B extends A{}  //报错

class C{
    //要求hi不能被子类重写
    public final void hi(){}
}

class D extends C{
//    @Override
//    public void hi(){
//        System.out.println("尝试重写");
//    }
}

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

///当不希望某个局部变量被修改，可以使用 final 修饰
class F{
    public void cry(){
        final double NUM = 0.01;
//        NUM = 0.9; //会报错
        System.out.println("NUM = " + NUM);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

10.5.2 final使用注意事项和细节讨论

• final修饰的属性又叫常量一般用XX_XX_XX来命名
• final修饰的属性在定义时必须赋初值,并且以后不能再修改，赋值可以在如下位置之一
  1. 定义时
  2. 构造器
  3. 代码块
• 如果final修饰的属性是静态的，则初始化的位置只能是
  • 定义时
  • 在静态代码块
• final类不能继承,但是可以实例化对象。
• 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。

举个栗子

package com.dingjiaxiong.final_;

/**
 * ClassName: FinalDetail01
 * date: 2022/9/3 19:41
 *
 * @author DingJiaxiong
 */

public class FinalDetail01 {
    public static void main(String[] args) {
        CC cc = new CC();

        new EE().cal();
    }
}

class AA{
    public final double TAX_RATE = 0.08; //定义时赋值
    public final double TAX_RATE2;
    public final double TAX_RATE3;

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

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

class BB{
    public static final double TAX_RATE = 99.9;
    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{}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

运行结果

【一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法了】

【final不能修饰构造方法(构造器)】

【final和static往往搭配使用，效率更高，不会导致类加载 - 底层编译器做了优化处理】

【包装类(Integer 、Double、Float 、 Boolean等都是final)，String也是final类】

举个栗子

package com.dingjiaxiong.final_;

/**
 * ClassName: FinalDetail02
 * date: 2022/9/3 19:50
 *
 * @author DingJiaxiong
 */

public class FinalDetail02 {
    public static void main(String[] args) {
        System.out.println(BBB.num);
    }
}

class BBB{
    public final static int num = 10000;
    static {
        System.out.println("BBB静态代码块被执行");
    }
}

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

//String是final类，不能被继承
//class CCC extends String{
//
//}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

运行结果

10.5.3 final应用实例

请编写一个程序，能够计算圆形的面积。要求圆周率为3.14.

package com.dingjiaxiong.final_;

/**
 * ClassName: FinalExercise01
 * date: 2022/9/3 19:54
 *
 * @author DingJiaxiong
 */

public class FinalExercise01 {
    public static void main(String[] args) {
        Circle circle = new Circle(5.0);
        System.out.println("面积 = " + circle.calArea());
    }
}

class Circle{
    private double radius;
    private final double PI = 3.14;

    public Circle(double radius){
        this.radius = radius;
    }

    public double calArea(){
        return PI * radius * radius;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

运行结果