第38章 final关键字

作者：张子默

一、概述

在了解了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们如果随意的继承API中提供的类并改写其内容显然是不合适的。为了避免这种随意改写的情况，Java提供了final关键字，用于修饰不可改变内容。

• final：不可改变。可以用于修饰类、方法和变量。
  • 类：被修饰的类，不能被继承。
  • 方法：被修饰的方法，不能被重写。
  • 变量：被修饰的变量，不能被重新赋值。

二、使用方式

1、修饰类

格式如下：

final class 类名 {
}
1
2

插叙API发现像public final class String、public final class Math、public final class Scanner等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们随意改变其内容。

2、修饰方法

格式如下：

修饰符 final 返回值类型 方法名(参数列表){
	//方法体
}
1
2
3

重写被final修饰的方法，编译时会报错。

3、修饰变量

• 局部变量——基本类型

基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：

public class FinalDemo1 {
    public static void main(String[] args) {
        // 声明变量，使用final修饰
        final int a;
        // 第一次赋值
        a = 10;
        // 第二次赋值
        a = 20; // 报错,不可重新赋值
        // 声明变量，直接赋值，使用final修饰
        final int b = 10;
        // 第二次赋值
        b = 20; // 报错,不可重新赋值
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

思考题：下面两种写法，哪种可以通过编译。

写法1：

final int c = 0;
for (int i = 0; i < 10; i++) {
    c = i;
    System.out.println(c);
}
1
2
3
4
5

写法2：

for (int i = 0; i < 10; i++) {
    final int c = i;
    System.out.println(c);
}
1
2
3
4

根据final的定义，写法1报错！

• 局部变量——引用类型

引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能更改。但是不影响对象内部的成员变量值的修改，代码如下：

public class FinalDemo2 {
    public static void main(String[] args) {
        // 创建 User 对象
        final User u = new User();
        // 创建 另一个 User对象
        u = new User(); // 报错，指向了新的对象，地址值改变。
        // 调用setName方法
        u.setName("张三"); // 可以修改
    }
}
1
2
3
4
5
6
7
8
9
10

• 成员变量

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

显式初始化：

public class User {
    final String USERNAME = "张三";
    private int age;
}
1
2
3
4

构造方法初始化：

public class User {
    final String USERNAME ;
    private int age;
    public User(String username, int age) {
        this.USERNAME = username;
        this.age = age;
    }
}
1
2
3
4
5
6
7
8

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

三、实例

• final修饰类

package com.zzm.day11.demo01;

/**
 * 用途：
 * 时间：2021/6/23 20:17
 * 创建人：张子默
 */

/*
当final关键字用来修饰一个类的时候，格式：
    public final class 类名称 {
        // ...
    }

含义：当前这个类不能有任何子类。(太监类)
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写(因为没儿子。)
 */
public final class MyClass /*extends Object*/ {

    public void method() {
        System.out.println("方法执行！");
    }

}

package com.zzm.day11.demo01;

/**
 * 用途：
 * 时间：2021/6/23 20:22
 * 创建人：张子默
 */

// 不能使用一个final类作为父类
public class MySubClass /*extends MyClass*/ {

}
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

• final修饰方法

package com.zzm.day11.demo01;

/**
 * 用途：
 * 时间：2021/6/23 20:26
 * 创建人：张子默
 */

/*
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
    修饰符 final 返回值类型 方法名称(参数列表) {
        // 方法体
    }

注意事项：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
 */
public abstract class Fu {

    public final void method() {
        System.out.println("父类方法执行！");
    }

    public abstract /*final*/ void methodAbs();

}

package com.zzm.day11.demo01;

/**
 * 用途：
 * 时间：2021/6/23 20:26
 * 创建人：张子默
 */
public class Zi extends Fu {
    @Override
    public void methodAbs() {

    }

    // 错误写法！不能覆盖重写父类当中final的方法
    /*@Override
    public void method() {
        System.out.println("子类覆盖重写父类的方法！");
    }*/
}
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

• final修饰变量

package com.zzm.day11.demo01;

/**
 * 用途：
 * 时间：2021/6/23 20:55
 * 创建人：张子默
 */

/*
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样不可变。
    1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
    2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值，二者选其一。
    3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
 */
public class Person {

    private final String name/* = "鹿晗"*/;

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

    public Person() {
        this.name = "关晓彤";
    }

    public String getName() {
        return name;
    }

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

package com.zzm.day11.demo01;

/**
 * 用途：
 * 时间：2021/6/23 20:42
 * 创建人：张子默
 */
public class Student {

    private String name;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

package com.zzm.day11.demo01;

/**
 * 用途：
 * 时间：2021/6/23 20:15
 * 创建人：张子默
 */

/*
final关键字代表最终、不可改变的。

常见四种用法：
    1.可以用来修饰一个类
    2.可以用来修饰一个方法
    3.还可以用来修饰一个局部变量
    4.还可以用来修饰一个成员变量
 */
public class Demo01final {

    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1); // 10
        num1 = 20;
        System.out.println(num1); // 20

        // 一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
        // "一次赋值，终生不变"
        final int num2 = 200;
        System.out.println(num2); // 200

        // num2 = 250; // 错误写法！不能改变！
        // num2 = 200; // 错误写法！

        // 正确写法！只要保证有唯一一次赋值即可
        final int num3;
        num3 = 30;

        // 对于基本类型来说，不可变说的是变量当中的数据不可改变
        // 对于引用类型来说，不可变说的是变量当中的地址值不可改变
        Student stu1 = new Student("赵丽颖");
        System.out.println(stu1);
        System.out.println(stu1.getName()); // 赵丽颖
        stu1 = new Student("霍建华");
        System.out.println(stu1);
        System.out.println(stu1.getName()); // 霍建华
        System.out.println("===============");

        final Student stu2 = new Student("高圆圆");
        // 错误写法！final的引用类型变量，其中的地址不可改变
        System.out.println(stu2.getName()); // 高圆圆
        // stu2 = new Student("赵又廷");
        stu2.setName("高圆圆圆圆圆圆");
        System.out.println(stu2.getName()); // 高圆圆圆圆圆圆
    }

}
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118