Skip to content

4. 类、记录、接口

4.1. 通过示例理解对象

4.1.1. 概述

现在我们通过示例来探索面向对象编程。对象是一种实体,它包含定义其状态的数据(称为字段、属性等)和函数(称为方法)。对象是根据称为类的模板创建的。例如,名为 [C1] 的类声明了两个字段 [Type1 p1;] 和 [Type2 p2;],以及两个方法 [Type3 m3(...) { ... }] 和 [Type4 m4(...) { ... }],它们都包含在声明 [public class C1 { ... }]的花括号之内。

从类 [C1]可以创建许多对象,例如 [o1]、[o2]……它们都具有字段 [p1]、[p2]……以及方法 [m3]、[m4]……不过,它们的 [pi]字段会有不同的值,因此每个对象都有自己独特的状态。如果 [o1] 是类型为 [C1]的对象,[o1.p1] 指的是 [p1]字段,即 [o1],的字段,而 [o1.m3(...)] 指的是对 [m3]方法(即 [o1]的方法)的调用。

我们来考虑第一个对象模型:类 [Person]。

4.1.2. 由多个文件组成的程序

在上一章的示例中,一个程序只放在一个源文件中。从现在起,一个程序可以由多个源文件组成:每个文件一个类,再加上主程序。在 Java 中,公共类必须放在以它命名的文件中:公共类 [Person] 位于文件 [Person.java]。我们把同一个程序的文件存放在一个文件夹中——这里是 [Persons]文件夹,位于 [04-classes]文件夹内:

1
2
3
Persons/
  Person.java       the Person class
  Main.java         the main program

自 Java 22 起,源文件启动器——我们在上一章已经使用过——可以运行由多个文件组成的程序:在 [java Main.java]命令(在 [Persons]文件夹中输入)下,它在内存中编译文件 [Main.java],然后按需编译文件夹中它所需要的其他文件——这里是 [Person.java]——然后运行程序。不会向磁盘写入任何已编译的文件。你也可以用 [javac]编译器显式编译这些文件,它为每个类写出一个 [.class]文件(中间代码,即“字节码”),然后用 [java]命令运行程序,并指定在哪里找到已编译的类(选项 [-cp],即“类路径”):

1
2
3
4
5
6
> javac -d classes *.java
> ls classes
Main.class
Person.class
> java -cp classes Main
[Jean, Dupont, 30]

多文件启动器足以应付本章的程序,这些程序只使用 JDK 中的类。当程序需要外部库时,我们将使用 Maven 项目,如第 2 章所介绍:Maven 下载这些库、编译项目并运行它。本章的文件可以原样在 IntelliJ IDEA 或 VS Code 中打开。

4.1.3. Person 类的定义

[Person]类在源文件 [Person.java] 中的定义如下:

public class Person {
    // 属性(字段)
    private String firstName = "";
    private String lastName = "";
    private int age;

    // 方法
    public void initialize(String p, String n, int age) {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

    // 方法
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 第 1 行:该类是公共的([public]):所有其他类都可以使用它。它不属于任何包——更准确地说,它属于未命名包;包将在本章末尾讨论;
  • 第 3–5 行:类的三个字段。两个字符串都用空字符串初始化:否则,创建对象时它们会被设为 [null] (未初始化的对象字段被设为 [null],数值字段被设为 0,布尔字段被设为 [false]);
  • 第 8–12 行:设置对象状态的方法;
  • 第 15–17 行:显示对象状态的方法。[IO] 是我们在上一章使用过的 Java 25 控制台输入/输出类。

这里我们看到的是一个类的定义——也就是一种数据类型。当我们创建这种类型的变量时,称之为对象或类的实例。因此,类是构造对象所用的模板。按照惯例,类名以大写字母开头([Person]),而字段名或方法名以小写字母开头([firstName]、[initialize])。

类的成员可以是数据(字段)或方法(函数)。这些成员可以带有下列关键字之一:

关键字
访问权限
[private]
私有成员只能被类的内部方法访问
(无)
如果没有指定关键字,该成员可以被同一包中任何类的方法访问。这是默认访问权限,称为“包访问权限”
[protected]
受保护成员可以被同一包中类的方法以及派生类的方法访问(见下文继承的概念)
[public]
公共成员可以被任何方法访问,无论该方法是否定义在该类之内

一般来说,类的数据声明为私有,而它的方法声明为公共。这意味着对象的使用者(程序员):

  • 不能直接访问对象的私有数据;
  • 可以调用对象的公共方法,包括那些提供对其私有数据访问的方法。

声明 [private]、[protected]和 [public] 成员的顺序是任意的。请注意,默认访问权限并不是 private:不带关键字声明的字段对包中的所有类都是可见的。因此,你必须记得写 [private]。

4.1.4. initialize 方法

[initialize]方法的作用是什么?由于 [lastName], [firstName],和 [age] 是 [Person]类的私有成员,在主程序中写出的类似 [p1.firstName = "Jean";]的语句是无效的。编译器会拒绝它:

1
2
3
4
5
6
> java Main.java
Main.java:4: error: firstName has private access in Person
    p1.firstName = "Jean";
      ^
1 error
error: compilation failed

编译器消息是英文的:JDK 的消息没有法语翻译。它指明了出错的文件和行号,然后用插入符号标出出错位置。我们需要通过公共方法来初始化类型为 [Person] 的对象。这就是 [initialize] 方法的作用。我们将写 [p1.initialize("Jean", "Dupont", 30);]。这种语法是有效的,因为 [initialize] 是公开可访问的。

4.1.5. new 运算符

不过,还缺少一些东西。声明 [Person p1;] 把 [p1] 声明为对 [Person] 类型对象的引用。这个对象尚不存在,因此 [p1] 没有被初始化。当我们接着写 [p1.initialize("Jean", "Dupont", 30);]时,我们调用了 [initialize] 方法,该方法属于由 [p1]引用的对象。然而,这个对象并不存在,编译器会报告错误:局部变量 [p1] 尚未被赋值。

1
2
3
4
5
6
> java Main.java
Main.java:4: error: variable p1 might not have been initialized
    p1.initialize("Jean", "Dupont", 30);
    ^
1 error
error: compilation failed

如果我们写 [Person p1 = null;] 后接 [p1.initialize("Jean", "Dupont", 30);],就是用关键字 [null] 显式地表明变量 [p1] 尚未引用任何对象。编译器接受该程序,但在运行时,方法调用会触发 [NullPointerException]异常:

1
2
3
> java Main.java
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Person.initialize(String, String, int)" because "<local1>" is null
    at Main.main(Main.java:4)

自 Java 14 起,异常消息会指明哪个操作失败;[<local1>] 指的是局部变量 [p1],它的名称没有被内存中的编译保留下来。要让 [p1]引用一个对象,必须写 [Person p1 = new Person();]。

这会创建一个尚未初始化的 [Person]类型的对象:它的字段具有默认值——这里,[lastName] 和 [firstName], 为空字符串,[age]为 0。现在 [p1] 引用了一个对象,该对象的初始化语句 [p1.initialize("Jean", "Dupont", 30);],就是有效的了。

4.1.6. this 关键字

我们来看 [initialize]方法的代码:

    public void initialize(String p, String n, int age) {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

语句 [this.firstName = p;] 表示当前对象([firstName] )的字段 [this]被赋予值 [p]。关键字 [this] 指当前对象:即执行该方法所针对的那个对象。我们怎么知道这一点?来看调用程序中由 [p1]引用的对象是如何被初始化的:[p1.initialize("Jean", "Dupont", 30);]。被调用的是对象 [initialize] 的 [p1] 方法。当在这个方法内部引用对象 [this]时,它实际上指的是对象 [p1]。

当对象的某个方法引用该对象的字段 [a] 时,记法 [this.a] 是隐含的:[initialize] 方法本来可以写成 [firstName = p;] 和 [lastName = n;]。当标识符发生冲突时,必须显式使用 [this] 。语句 [this.age = age;] (第 11 行)就是这种情况,其中 [age] 既指当前对象的字段,也指方法接收的参数 [age]。在方法中,单独的名称 [age] 指的是参数;字段必须写成 [this.age]。

4.1.7. 测试程序

下面是一个简短的测试程序,它写在源文件[Main.java]中:

1
2
3
4
5
6
7
// 主程序
void main() {
    // 一个 Person 对象
    Person p1 = new Person();
    p1.initialize("Jean", "Dupont", 30);
    p1.identify();
}
  • 第 2 行:[main] 方法是程序的入口点。与上一章一样,它没有写在封闭类中:文件[Main.java] 是一个紧凑源文件(见下一段);
  • 第 4 行:创建一个由[p1]引用的 [Person] 对象。由于 [Person] 类与程序属于同一个包(未命名包),因此无需 import 语句即可识别;
  • 第 5 行:对象的初始化;
  • 第 6 行:显示其状态。

结果:

> java Main.java
[Jean, Dupont, 30]

4.1.8. 紧凑源文件

对于一个简短的示例来说,使用包含多个文件的文件夹显得过于庞大。因此,与上一章一样,我们编写一个紧凑源文件(Java 25):即包含方法[void main()]、可能还有其他方法和字段以及程序所需类的文件。我们使用源代码启动器来运行它:[java Classes01.java]。

理解编译器如何处理这样的文件很重要。它会把文件包装在一个隐式类中,该类以文件名命名([Classes01]):文件中的方法和字段成为这个类的成员,而文件中声明的类则成为这个隐式类的嵌套类。对该文件进行显式编译可以证明这一点:

1
2
3
4
> javac -d classes Classes01.java
> ls classes
Classes01$Person.class
Classes01.class

因此,文件[Person] 类在[Classes01.java] 中的完整名称是[Classes01$Person]。这会带来两个后果,我们将在示例中遇到:

  • 一个类与它所包含的类共享各自的私有成员:紧凑文件中的[main]方法可以访问该文件中各个类的私有字段。要确保私有字段无法从其类外部访问,就必须像在[Persons]文件夹中那样,把该类放在它自己的文件中;
  • 普通的嵌套类是内部类:它的对象与外围类的某个对象绑定。只要对象是由文件中的方法创建的,这一点就不明显,但静态方法(见关于类成员的一节)无法创建它们。这时我们把嵌套类声明为[static]。后面要讨论的记录和接口总是静态的。

最后,紧凑文件会自动导入[java.base]模块中所有的公共类:[List]、[ArrayList]、[BigDecimal]、[Objects]……都可以在其中直接使用,无需[import]子句。而对于常规文件,例如[Person.java],则并非如此,我们将会看到。

4.1.9. 另一个 initialize 方法:重载

我们继续讨论[Person] 类,并为它添加第二个方法:[initialize]。程序[Classes01.java] 如下:

// initialize 方法的重载
void main() {
    Person p1 = new Person();
    p1.initialize("Jean", "Dupont", 30);
    p1.identify();
    Person p2 = new Person();
    p2.initialize(p1);
    p2.identify();
}

// Person 类声明在 main 方法之后
class Person {
    // 属性
    private String firstName = "";
    private String lastName = "";
    private int age;

    // 用三个值初始化
    public void initialize(String p, String n, int age) {
        firstName = p;
        lastName = n;
        this.age = age;
    }

    // 用另一个人初始化
    public void initialize(Person p) {
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // 此人的身份信息
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 第 2–9 行:主程序;
  • 第 12 行:[Person] 类声明在[main]方法之后。它不是 public 的:在紧凑文件中没有必要这样做;
  • 第 19–23 行:上一段中的[initialize]方法;
  • 第 26–30 行:第二个方法,[initialize]。

现在我们有两个名为[initialize]的方法:只要它们接受不同的参数(数量或类型不同),这就是合法的。此时称方法 [initialize]被重载。编译器根据实际参数选择要调用的方法:[p1.initialize("Jean", "Dupont", 30)] (第 4 行)调用第一个方法,而[p2.initialize(p1)] (第 7 行)调用第二个方法。仅凭返回类型不足以区分两个方法:名称和参数相同、仅返回类型不同的两个方法会被拒绝。

第二个方法的参数是对某个人的引用([p])。该人的字段([p])随后被赋给当前对象([this])。请注意,方法[initialize] 可以直接访问对象[p] 的字段,尽管这些字段是私有的(第 27–29 行)。这一点始终成立:类[C] 的方法可以访问同一个类[C]的所有对象的私有成员。

结果:

1
2
3
> java Classes01.java
[Jean, Dupont, 30]
[Jean, Dupont, 30]

4.1.10. Person 类的构造函数

构造函数是一种与类同名、在创建对象时被调用的方法。它通常用于初始化对象。它是可以接受参数但不返回值的方法,其声明前面不带任何类型(甚至不带[void])。

如果类[C] 有一个接受 n 个参数的构造函数,则该类对象的声明和初始化可以写成[C object = new C(arg1, arg2, ... argn);]的形式,也可以分两步完成:先写[C object;],稍后再写[object = new C(arg1, arg2, ... argn);]。

当类[C] 有一个或多个构造函数时,必须使用其中一个构造函数来创建该类的对象。如果类[C] 没有构造函数,则它有一个什么也不做的无参默认构造函数,对象的字段保持其初始值。在前面的程序中就是这种情况,我们当时写的是[new Person()]。

程序[Classes02.java] 为类[Person]提供了三个构造函数:

// Person 类的构造函数
void main() {
    Person p1 = new Person("Jean", "Dupont", 30);
    p1.identify();
    Person p2 = new Person(p1);
    p2.identify();
    Person p3 = new Person();
    p3.identify();
}

class Person {
    // 属性
    private String firstName;
    private String lastName;
    private int age;

    // 主构造函数
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // 拷贝构造函数:它调用主构造函数
    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // 无参构造函数:它同样调用主构造函数
    public Person() {
        this("?", "?", 0);
    }

    // 此人的身份信息
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 第 18–22 行:“主”构造函数初始化三个字段。由于它的参数与字段同名,因此使用[this]来区分字段;
  • 第 25–27 行:复制构造函数。语句[this(p.firstName, p.lastName, p.age);] 调用同一个类中接受三个参数的构造函数:[String]、[String]和[int]。这称为构造函数链式调用。这样,初始化代码只需写一次;
  • 第 30–32 行:无参构造函数,它同样链接到主构造函数。由于该类已经声明了构造函数,因此它不再有默认构造函数:如果希望能够写[new Person()],就必须声明它;
  • 第 13–15 行:字段不再在声明时初始化;所有构造函数都直接或通过链式调用为它们赋值。

对另一个构造函数的调用[this(...)] 只能在构造函数内部进行。在 Java 24 及之前,它必须是第一条语句;自 Java 25 起,不使用正在构造的对象的语句(例如用于验证或准备参数的语句)可以放在它之前。我们也可以让构造函数调用诸如[initialize]之类的方法;不过,链式调用更可取:初始化代码集中在一处,而且构造函数不应调用派生类可能重写的方法——我们稍后会说明原因。

结果:

1
2
3
4
> java Classes02.java
[Jean, Dupont, 30]
[Jean, Dupont, 30]
[?, ?, 0]

4.1.11. 对象引用

我们使用上一个程序中的[Person]类,省略其无参构造函数,但保留本章开头的[initialize(String, String, int)]方法。测试程序变为下面的[Classes03.java]:

// 对象引用
void main() {
    // p1
    Person p1 = new Person("Jean", "Dupont", 30);
    IO.print("p1="); p1.identify();
    // p2 引用与 p1 相同的对象
    Person p2 = p1;
    IO.print("p2="); p2.identify();
    // p3 引用的对象是 p1 所引用对象的副本
    Person p3 = new Person(p1);
    IO.print("p3="); p3.identify();
    // 我们改变 p1 所引用对象的状态
    p1.initialize("Micheline", "Benoît", 67);
    IO.print("p1="); p1.identify();
    // 由于 p2 = p1,p2 所引用的对象状态也变了
    IO.print("p2="); p2.identify();
    // p3 与 p1 不引用同一个对象:p3 所引用的对象没有变化
    IO.print("p3="); p3.identify();
    // p1 和 p2 是同一个引用吗?p1 和 p3 呢?
    IO.println("p1 == p2 : " + (p1 == p2) + ", p1 == p3 : " + (p1 == p3));
}

class Person {
    // 属性
    private String firstName;
    private String lastName;
    private int age;

    // 构造函数
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // 初始化
    public void initialize(String p, String n, int age) {
        firstName = p;
        lastName = n;
        this.age = age;
    }

    // 此人的身份信息
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}

[IO.print]方法(第 5、8 行等)输出其参数而不换行。结果:

1
2
3
4
5
6
7
8
> java Classes03.java
p1=[Jean, Dupont, 30]
p2=[Jean, Dupont, 30]
p3=[Jean, Dupont, 30]
p1=[Micheline, Benoît, 67]
p2=[Micheline, Benoît, 67]
p3=[Jean, Dupont, 30]
p1 == p2 : true, p1 == p3 : false

当[p1] 通过 [Person p1 = new Person("Jean", "Dupont", 30);] (第 4 行)声明时,[p1] 引用对象 [Person("Jean", "Dupont", 30)],但并不是对象本身。在 C 语言中,这被称为指针,即所创建对象的地址。如果我们随后写[p1 = null;],被修改的并不是对象 [Person("Jean", "Dupont", 30)],而是引用[p1] 改变了它的值。如果没有其他变量引用该对象,它就会“丢失”:它占用的内存稍后将由 Java 虚拟机的垃圾回收器回收。

当我们写[Person p2 = p1;] (第 7 行)时,我们初始化了引用[p2]:它与引用[p1]一样“指向”同一个对象(引用同一个对象)。因此,如果[p1]所“指向”(或引用)的对象被修改,那么[p2]所引用的对象也会被修改(结果的第 5–6 行)。

当写下 [Person p3 = new Person(p1);](第 10 行)时,会创建一个新的[Person]对象。这个新对象将由[p3]引用。如果修改[p1]所引用的对象,并不会修改[p3] 所引用的对象(结果的第 7 行)。

最后,在第 20 行,运算符[==]应用于两个对象引用时,表示它们是否引用同一个对象:[p1] 和[p2] 引用同一个对象,而[p1] 和[p3] 引用两个不同的对象,尽管它们的内容相同(结果的第 8 行)。稍后我们将看到如何使用[equals]方法比较两个对象的内容。

4.1.12. 传递对象引用参数

在上一章中,我们看到 Java 按值传递方法参数:方法接收的是实参值的副本。下面来看看当参数是对象引用时这意味着什么。为此,我们将使用 JDK 中的[StringBuilder]类。[String]对象不能被修改:诸如[s.toUpperCase()] 之类的操作会返回一个新的[String]对象。而[StringBuilder]对象则是可变字符串:它的[append]方法向字符串添加字符,而不会创建新对象。

程序[Classes04.java] 如下:

// 传递对象引用类型的参数
void main() {
    StringBuilder sb0 = new StringBuilder("test0"), sb1 = new StringBuilder("test1");
    IO.println("In calling function before call: sb0=" + sb0 + ", sb1=" + sb1);
    StringBuilder sb2 = changeStringBuilder(sb0, sb1);
    IO.println("In calling function after call: sb0=" + sb0 + ", sb1=" + sb1 + ", sb2=" + sb2);
}

// 被调用的函数
StringBuilder changeStringBuilder(StringBuilder sbf0, StringBuilder sbf1) {
    IO.println("Start of called function: sbf0=" + sbf0 + ", sbf1=" + sbf1);
    // 我们修改 sbf0 所引用的对象
    sbf0.append("*****");
    // sbf1 现在引用一个新对象
    sbf1 = new StringBuilder("test1*****");
    // 一个新对象返回给调用者
    StringBuilder sbf2 = new StringBuilder("test2*****");
    IO.println("End of called function: sbf0=" + sbf0 + ", sbf1=" + sbf1 + ", sbf2=" + sbf2);
    return sbf2;
}
  • 第 3 行:两个引用[sb0] 和[sb1],指向[StringBuilder]类型的对象;
  • 第 5 行:它们被传递给方法[changeStringBuilder],该方法的结果(第三个引用)被赋给[sb2];
  • 第 10–20 行:紧凑文件中的一个方法,其形式参数为[sbf0] 和[sbf1]。方法开始时,[sbf0] 和[sb0] 是指向同一个对象的两个不同的引用:引用[sb0] 被复制到了[sbf0]中(引用是按值传递的)。[sbf1] 和[sb1]也是如此。

结果:

1
2
3
4
5
> java Classes04.java
In calling function before call: sb0=test0, sb1=test1
Start of called function: sbf0=test0, sbf1=test1
End of called function: sbf0=test0*****, sbf1=test1*****, sbf2=test2*****
In calling function after call: sb0=test0*****, sb1=test1, sb2=test2*****

说明:

  • [sb0] 和[sbf0] 是指向同一个对象的两个不同的引用。该对象通过[sbf0] 被修改(第 13 行)。通过[sb0] 可以看到这一修改(结果的第 5 行);
  • [sb1] 和[sbf1] 是指向同一个对象的两个不同的引用。[sbf1] 在方法中被赋予新值,现在指向一个新对象(第 15 行)。这不会改变[sb1]的值,它仍然指向原来未被修改的对象;
  • 因此,Java 方法无法改变调用方变量的值。要把新对象传回给调用方,就要把它作为结果返回(第 17 行和第 19 行)。当有多个结果时,把它们组合成一个对象,例如记录(见下文)。

请记住,方法可以修改参数所引用的对象,但不能修改调用方中保存该引用的变量。与 C# 等其他语言不同,Java 不支持按引用传递参数。

4.1.13. 临时对象

在表达式中,可以显式调用对象的构造函数:对象被创建,但没有变量可供日后访问它(例如用于修改它)。这个临时对象是为了计算表达式而创建的,随后就被丢弃。它占用的内存空间稍后将由垃圾回收器自动回收,垃圾回收器的作用是回收那些不再被程序数据引用的对象所占用的内存空间。

请看下面的程序[Classes05.java],其中[Person]类的构造函数会显示一条消息:

// 临时对象
void main() {
    new Person(new Person("Jean", "Dupont", 30)).identify();
}

class Person {
    // 属性
    private String firstName;
    private String lastName;
    private int age;

    // 构造函数
    public Person(String firstName, String lastName, int age) {
        IO.println("Constructor Person(String, String, int)");
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person(Person p) {
        IO.println("Constructor Person(Person)");
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // 此人的身份信息
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 第 3 行:对象 [Person("Jean", *"Dupont", 30)]* 被构造出来,然后传递给复制构造函数,由后者构造第二个对象,并调用该对象的方法 [identify] 。这两个对象都没有被变量引用。

结果:

1
2
3
4
> java Classes05.java
Constructor Person(String, String, int)
Constructor Person(Person)
[Jean, Dupont, 30]

结果显示了两个临时对象依次被创建。

4.1.14. 访问器和修改器

我们向[Person]类添加必要的方法,以读取或修改[Classes06.java]中对象字段的状态:

// 读取(getter)和写入(setter)私有属性的方法
void main() {
    Person p = new Person("Jean", "Michelin", 34);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    p.setAge(56);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
}

class Person {
    // 属性
    private String firstName;
    private String lastName;
    private int age;

    // 构造函数
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // getter
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // setter
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
  • 第 23–33 行:读取方法,称为 getter;
  • 第 36–46 行:写入方法,称为“setter”。

结果:

1
2
3
> java Classes06.java
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)

这些方法的命名遵循自 Java 早期就确立的约定,即“JavaBeans”:字段[age] 的 getter 名为[getAge],其 setter 名为[setAge];而名为[active] 的布尔字段的 getter 则称为[isActive]。许多库(例如用于 JSON 的 Jackson 和用于数据库的 Hibernate,我们稍后会用到)依赖这一约定来获取对象的数据。与 C# 等其他语言不同,Java 没有“属性”:访问对象的状态总是要通过方法,或者(对于不可变对象)通过记录,我们稍后会介绍。开发环境可以根据字段生成 getter 和 setter(在 IntelliJ IDEA 中,位于“Code / Generate…”菜单下)。

4.1.15. 验证所接收值的 setter

与公共字段相比,修改器的优势在于可以控制赋给字段的值:修改器可以验证所接收值的有效性,并在无效时抛出异常。请看程序[Classes07.java]:

// 检查所接收值有效性的 setter
void main() {
    Person p = new Person("Jean", "Michelin", 34);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    p.setAge(56);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    try {
        p.setAge(-4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    // 无参构造函数,然后调用 setter
    Person p2 = new Person();
    p2.setAge(7);
    p2.setFirstName("Arthur");
    p2.setLastName("Martin");
    IO.println("p2=(" + p2.getFirstName() + "," + p2.getLastName() + "," + p2.getAge() + ")");
    try {
        Person p3 = new Person();
        p3.setFirstName("Paul");
        p3.setLastName(" ");
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
}

class Person {
    // 属性
    private String firstName = "";
    private String lastName = "";
    private int age;

    // 构造函数
    public Person(String firstName, String lastName, int age) {
        // 我们通过 setter 来利用其中的检查
        setFirstName(firstName);
        setLastName(lastName);
        setAge(age);
    }

    public Person() {
    }

    // getter
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // setter:它们被声明为 final,因为构造函数会调用它们
    public final void setFirstName(String firstName) {
        // 名字有效吗?
        if (firstName == null || firstName.isBlank()) {
            throw new IllegalArgumentException("first name (" + firstName + ") invalid");
        }
        this.firstName = firstName;
    }

    public final void setLastName(String lastName) {
        // 姓氏有效吗?
        if (lastName == null || lastName.isBlank()) {
            throw new IllegalArgumentException("last name (" + lastName + ") invalid");
        }
        this.lastName = lastName;
    }

    public final void setAge(int age) {
        // 年龄有效吗?
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
    }
}

三个修改器都会验证所接收的值(第 60–62、68–70、76–78 行)。

  • 第 60–62 行:方法[isBlank] (Java 11)在字符串为空或仅由空格组成时返回[true] 。首先执行 [firstName == null] 测试:如果[firstName] 等于[null],运算符[||] 就不会计算其第二个操作数,否则会引发[NullPointerException]异常。抛出的异常类型是[IllegalArgumentException],这是 Java 提供的用于表示无效参数的异常。这是一个非受检异常:方法无需用[throws]声明它;
  • 第 34–39 行:构造函数通过访问器而不是字段来初始化对象。这样它就可以利用访问器所执行的验证,而这些验证只需在一处编写;
  • 第 58、66、74 行:修改器被声明为[final]。在学习继承时我们会看到,派生类可以重写其父类的方法;关键字[final] 可以防止这一点。如果没有它,派生类就可以重新定义[setAge],而[Person] 的构造函数甚至会在派生类的构造函数执行之前就调用这个新版本。编译器在使用[-Xlint:all]选项时,会针对写在独立文件中的公共类提示这一风险(警告[this-escape]);
  • 第 41–42 行:无参构造函数,它使字段保持初始值。

结果:

1
2
3
4
5
6
> java Classes07.java
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)
age (-4) invalid
p2=(Arthur,Martin,7)
last name ( ) invalid

结果的第 4 行表明,对[p.setAge(-4)] (第 8 行)的调用被修改器拒绝了。第 13–16 行:使用无参构造函数创建一个实例,然后通过其 setter 对其进行初始化。第 19–21 行:包含空格的名字被拒绝(结果的第 6 行)。

与其他语言不同,Java 没有对象初始化器,即一种可以在[new]表达式本身中设置多个字段的语法:相反,如这里所示,我们链式调用构造函数和 setter,或者编写一个接受所有值的构造函数。我们还将介绍另外两种解决方案:“流式”修改器和记录。

4.1.16. final 字段和必需参数

声明为[final] 的字段必须恰好被赋值一次——要么在声明时,要么在每个构造函数中——此后不能再修改。编译器会强制执行这条规则。再结合不提供修改器,就可以创建只读数据。程序[Classes08.java] 演示了几种情况:

// final 字段,只读,必需参数
void main() {
    Person p = new Person("Jean", "Dupont", 30, "Angers");
    IO.println(p.getIdentity());
    // 名字可读/可写
    p.setFirstName("Jacques");
    // 年龄只能在类内部修改
    p.growOlder();
    IO.println(p.getIdentity());
    // 以下几行会被编译器拒绝
    // p.setLastName("Durand"); // 姓氏没有 setter
    // p.setAge(40);         // 年龄没有 setter
    // p.city = "Paris";     // city 字段是 final

    // 必需参数
    Contact c = new Contact("jean.dupont@example.com");
    IO.println("Contact: " + c.getEmail() + ", " + c.getPhone());
    try {
        Contact c2 = new Contact(null);
        IO.println("Contact: " + c2.getEmail());
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
}

class Person {
    // 字段
    private String firstName;
    // final 字段:它们在构造函数中一次性获得值
    private final String lastName;
    private final String city;
    private int age;

    // 构造函数
    public Person(String firstName, String lastName, int age, String city) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.city = city;
    }

    // 名字可读/可写
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    // 姓氏、年龄和城市只读
    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public String getCity() {
        return city;
    }

    // 计算得出的值
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + ", " + city + "]";
    }

    // 年龄只由类的方法修改
    public void growOlder() {
        age++;
    }
}

class Contact {
    // 电子邮件必填,电话可选
    private final String email;
    private final String phone;

    // 带两个值的构造函数
    public Contact(String email, String phone) {
        this.email = Objects.requireNonNull(email, "the email is mandatory");
        this.phone = phone;
    }

    // 不带电话的构造函数:使用默认值
    public Contact(String email) {
        this(email, "unknown");
    }

    public String getEmail() {
        return email;
    }

    public String getPhone() {
        return phone;
    }
}
  • 第 28 行和第 43–49 行:名字既是只读的又是可写的;它有一个 getter 和一个 setter;
  • 第 30–31 行:姓和城市是[final]字段。构造函数为它们赋值(第 37 行和第 39 行),此后不能再更改;
  • 第 32 行和第 56–58 行:年龄任何人都可以读取,但没有公共的 setter;它只能由类自己的方法修改,例如[growOlder] (第 70–72 行);
  • 第 65–67 行:方法[getIdentity] 返回根据字段计算出的值。对于类的使用者来说,它与访问器没有区别;
  • 第 11–13 行:编译器拒绝的三条语句,原因已在注释中给出。对于第三条,编译器的消息是:[cannot assign a value to final variable city];
  • 第 75–98 行:[Contact]类有一个必需字段(电子邮件)和一个可选字段(电话)。必需字段由构造函数强制保证:没有电子邮件地址就无法创建[Contact]对象。方法[Objects.requireNonNull(value, message)](第 82 行)在其第一个参数不为[null] 时返回该参数,否则抛出带有指定消息的[NullPointerException]异常:形如[null] 的电子邮件地址会被拒绝(第 18–23 行);
  • 第 87–89 行:电话号码的可选性通过第二个构造函数来表达,它提供了一个默认值。Java 没有可选参数:我们通过重载构造函数来实现。

请注意,在紧凑文件中,方法[main] 可以访问文件中各个类的私有字段:因此,第 11–13 行的注释依据的并不是字段的私有性质,而是没有修改器以及关键字[final]。

结果:

1
2
3
4
5
> java Classes08.java
[Jean, Dupont, 30, Angers]
[Jacques, Dupont, 31, Angers]
Contact: jean.dupont@example.com, unknown
Error: the email is mandatory

4.1.17. 流式修改器

当一个对象有许多可选字段时,构造函数的数量会增加,修改器调用也会变得更长。一种常见的技巧是让每个修改器返回当前对象([this]):这样调用就可以链接在一起,这称为“流式”方法。程序[Classes09.java] 对此进行了说明:

// “流式”setter:它们返回当前对象
void main() {
    Person p = new Person().setFirstName("  jean ").setLastName("Dupont").setAge(30);
    IO.println(p.getIdentity());
    try {
        p.setLastName("");
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    try {
        p.setAge(-4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    IO.println(p.getIdentity());
}

class Person {
    // 字段
    private String firstName = "";
    private String lastName = "";
    private int age;

    // 流式 setter:每个都返回当前对象(this)
    public Person setFirstName(String firstName) {
        this.firstName = check(firstName, "first name");
        return this;
    }

    public Person setLastName(String lastName) {
        this.lastName = check(lastName, "last name");
        return this;
    }

    public Person setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
        return this;
    }

    // 身份信息
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // 检查必填字符串:返回时去掉首尾空格
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value.strip();
    }
}
  • 第 25–28 行:修改器[setFirstName] 检查所接收的值,将其赋给字段,并返回当前对象。因此它的返回类型是[Person];
  • 第 3 行:调用被链接起来:[new Person()] 返回一个人,对其调用[setFirstName],它返回同一个人,再对其调用[setLastName],依此类推。这种语法类似于对象初始化器;
  • 第 49–54 行:对名字和姓氏的检查完全相同,被提取到私有方法[check]中。它被声明为[static] ,因为它不使用对象的任何字段(静态成员将在下一段讨论)。方法[strip] (Java 11)会去除字符串前后的空格。

结果:

1
2
3
4
5
> java Classes09.java
[jean, Dupont, 30]
last name () invalid
age (-4) invalid
[jean, Dupont, 30]

两侧带有空格提供的名字“jean”(第 3 行)在存储时去掉了这些空格(结果的第 2 行)。流式修改器不遵循 JavaBeans 约定,按照该约定,修改器不返回任何内容([void]):有些库无法识别它们。要构造复杂对象,还会使用“生成器”(Builder)设计模式:由一个配备流式方法的辅助类收集各个值,然后构造出最终对象,该对象还可以是不可变的。

4.1.18. 类方法和类属性

假设我们想统计应用程序中创建的 [Person] 对象的数量。我们可以自己管理一个计数器,但有可能忽略到处创建的临时对象。更稳妥的做法是在 [Person] 类的构造函数中加入一条递增计数器的指令。这个计数器不能是普通字段,因为每个对象都有自己的字段:它是类本身的字段,而不是该类某个特定实例的字段。它使用关键字[static]声明:[private static long nbPersons;]。

要引用它,我们写[Person.nbPersons] ,以表明它是 [Person] 类本身的字段。这里我们创建了一个私有字段,无法从类的外部直接访问。因此,我们创建一个公共访问器,以提供对类字段[nbPersons]的访问。为了获取 [nbPersons] 的值,这个访问器不需要特定的 [Person] 对象;因此,我们同样把它声明为 *[static]。从外部调用时,使用语法[Person.getNbPersons()]。下面是[Classes10.java]*的一个示例:

// 类成员(static)
void main() {
    Person p1 = new Person("Jean", "Dupont", 30);
    Person p2 = new Person(p1);
    new Person(p1);
    IO.println("Number of persons created: " + Person.getNbPersons());
    // 类方法
    Person p3 = Person.unknown();
    p3.identify();
    IO.println("Number of persons created: " + Person.getNbPersons());
}

// 静态嵌套类:参见说明
static class Person {
    // 类属性
    private static long nbPersons;

    // 类 getter
    public static long getNbPersons() {
        return nbPersons;
    }

    // 类方法
    public static Person unknown() {
        return new Person("?", "?", 0);
    }

    // 实例属性
    private String firstName;
    private String lastName;
    private int age;

    // 构造函数
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        nbPersons++;
    }

    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // 此人的身份信息
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 第 16 行:类字段。与任何数值字段一样,它被初始化为 0;
  • 第 19–21 行:类访问器;
  • 第 24–26 行:一个类方法。它通过类名调用:[Person.unknown()] (第 8 行)。类方法没有当前对象:关键字[this] 在其中没有意义,并且它只能直接使用类的[static]成员。像这样创建并返回其所属类对象的静态方法称为静态工厂方法;
  • 第 38 行:主构造函数使计数器递增。因此,链接到主构造函数的复制构造函数也会使其递增;
  • 第 14 行:类[Person] 被声明为[static]。正如紧凑文件一节所解释的:在紧凑文件中声明的类是隐式类的嵌套类。如果没有[static]关键字,它就是内部类,其每个对象都绑定到外围类的一个对象;没有当前对象的静态方法[unknown]就无法创建它,编译器会报告错误[non-static variable this cannot be referenced from a static context]。写在独立文件中的类不存在这个问题。

结果:

1
2
3
4
> java Classes10.java
Number of persons created: 3
[?, ?, 0]
Number of persons created: 4

程序正确地统计了第 5 行创建的临时对象。从一开始我们就在使用类成员:[IO.println]、[Integer.parseInt]、[Math.sqrt] 是 [static] 方法, 而[Math.PI] 是一个 [static]字段。类[Math] 只包含静态成员:它被声明为[final],其唯一的构造函数是私有的,从而阻止创建实例。这就是 Java 编写工具类的方式。

4.1.19. 人员数组

对象和其他数据一样,因此可以把多个对象归入一个数组[Classes11.java]:

// 人员数组
void main() {
    Person[] friends = new Person[3];
    friends[0] = new Person("Jean", "Dupont", 30);
    friends[1] = new Person("Sylvie", "Vartan", 52);
    friends[2] = new Person("Neil", "Armstrong", 66);
    // 显示
    for (Person friend : friends) {
        friend.identify();
    }
}

class Person {
    // 属性
    private String firstName;
    private String lastName;
    private int age;

    // 构造函数
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // 此人的身份信息
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 第 3 行:创建一个包含 3 个[Person]类型元素的数组。这 3 个元素此处被初始化为[null],即它们不引用任何对象。严格来说,我们把它称为“对象数组”,尽管它实际上只是对象引用的数组。数组的创建——数组本身也是对象(如[new]所示)——并不会创建与其元素同类型的任何对象;这必须随后再做;
  • 第 4–6 行:创建 3 个[Person]类型的对象;
  • 第 8–10 行:显示数组[friends]的内容。

结果:

1
2
3
4
> java Classes11.java
[Jean, Dupont, 30]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]

4.1.20. 类型推断和数组初始化

程序[Classes12.java] 包含两种简化对象和数组创建的构造:

// 用 var 进行类型推断和数组初始化
void main() {
    // 变量的类型由初始化它的表达式推断得出
    var p1 = new Person("Jean", "Dupont", 30);
    var p2 = new Person();
    p2.setFirstName("Arthur");
    p2.setLastName("Martin");
    p2.setAge(7);
    // 由花括号中的值列表创建并初始化的数组
    Person[] friends = {
        p1,
        p2,
        new Person("Sylvie", "Vartan", 52),
        new Person("Neil", "Armstrong", 66),
    };
    for (var friend : friends) {
        IO.println(friend.getIdentity());
    }
    // 作为参数传递的匿名数组
    display(new Person[] { new Person("Pauline", "Leduc", 12), p1 });
}

// 接收人员数组的方法
void display(Person[] persons) {
    for (Person p : persons) {
        IO.println("Display: " + p.getIdentity());
    }
}

class Person {
    // 字段
    private String firstName = "";
    private String lastName = "";
    private int age;

    // 构造函数
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person() {
    }

    // setter
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 身份信息
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}
  • 第 4 行:借助关键字[var] (Java 10),局部变量的类型由初始化它的表达式推断而来,这里是[Person]。不过变量仍然是有类型的:[p1] 的类型是 [Person],并且只能引用单个人。[var] 只能用于在声明时初始化的局部变量,不能用于字段或参数;
  • 第 10–15 行:用花括号括起、以逗号分隔的值列表创建并填充的数组。数组的大小就是值的个数。允许使用尾随逗号(第 14 行):这使得添加元素更容易。这种语法只允许在数组声明中使用;
  • 第 16 行:[var] 用于 [for] 循环中;
  • 第 20 行:在数组声明之外,创建已初始化的数组需要指定其类型:[new Person[] { ... }]。这称为匿名数组:在[main]方法中没有任何变量引用它;
  • 第 24–28 行:紧凑文件中接收人员数组的方法。

结果:

1
2
3
4
5
6
7
> java Classes12.java
[Jean, Dupont, 30]
[Arthur, Martin, 7]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]
Display: [Pauline, Leduc, 12]
Display: [Jean, Dupont, 30]

4.2. 通过示例学习继承

4.2.1. 概述

这里我们介绍继承的概念。继承的目的是“定制”现有的类,使其满足我们的需求。假设我们想创建一个类[Teacher]:教师是一种特殊类型的人。他们具有其他人没有的属性,例如所教授的科目。但他们也具有所有人共有的属性:名、姓和年龄。因此教师是类 [Person] 的正式成员,但还有额外的属性。与其从头创建类 [Teacher],我们更愿意在现有类 [Person] 的基础上进行构建,并使其适应教师的特殊性。继承的概念使这成为可能。

要表明类[Teacher] 继承自类[Person],我们写[public class Teacher extends Person]。

[Person] 称为父类(或基类、超类),而 [Teacher] 称为 派生类(或子类)。[Teacher] 对象具有 [Person] 对象的所有特性:它具有相同的字段和方法。父类的这些字段和方法不会在子类的定义中重复;我们只需指定子类新增的字段和方法。一个 Java 类只能继承自一个父类。

本段中的示例是位于 [Inheritance1] 和 [Inheritance2] 文件夹中的两个多文件程序。在 [Inheritance1] 文件夹中,[Person]类的定义如下:[Person.java]:

public class Person {
    // 类字段:已创建的人员数量
    private static long nbPersons;

    // 实例字段
    private String firstName;
    private String lastName;
    private int age;

    // 构造函数
    public Person(String firstName, String lastName, int age) {
        setFirstName(firstName);
        setLastName(lastName);
        setAge(age);
        nbPersons++;
        IO.println("Constructor Person(String, String, int)");
    }

    // 已创建的人员数量
    public static long getNbPersons() {
        return nbPersons;
    }

    // getter
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // setter
    public final void setFirstName(String firstName) {
        this.firstName = check(firstName, "first name");
    }

    public final void setLastName(String lastName) {
        this.lastName = check(lastName, "last name");
    }

    public final void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
    }

    // 此人的身份信息
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // 检查必填字符串
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value;
    }
}
  • 第 3 行:上一段中的人员计数器;
  • 第 11–17 行:构造函数通过修改器初始化对象、使计数器递增,并显示一条进度消息;
  • 第 38–51 行:三个验证其值的修改器。名和姓的验证完全相同,被提取到私有类方法[check] 中(第 59–64 行)。修改器被声明为[final] ,因为构造函数会调用它们(见程序[Classes07.java]);
  • 第 54–56 行:前面示例中的[identify]方法已被[getIdentity]方法取代,后者返回人员的身份信息,而不是显示它。

我们创建一个名为[Teacher] 的类,它继承自 [Person] 类:[Teacher.java]:

public class Teacher extends Person {
    // Teacher 类特有的字段
    private int section;

    // 构造函数
    public Teacher(String firstName, String lastName, int age, int section) {
        // 构造对象中的 Person 部分
        super(firstName, lastName, age);
        // 我们保存所属系
        this.section = section;
        // 跟踪
        IO.println("Constructor Teacher(String, String, int, int)");
    }

    // 所属系的 getter 和 setter
    public int getSection() {
        return section;
    }

    public void setSection(int section) {
        this.section = section;
    }
}

[Teacher]类在[Person]类的字段和方法基础上增加了:

  • 第 1 行:类[Teacher] 派生自类[Person];
  • 第 3 行:字段[section],即教师在教师队伍中所属教研组的编号(大致每个科目一个教研组);
  • 第 6–13 行:用于初始化教师所有字段的构造函数;
  • 第 16–22 行:[section]字段的 getter 和 setter。

4.2.2. 创建 Teacher 对象

子类不会继承父类的构造函数,必须定义自己的构造函数。[Teacher]类的构造函数如下:

1
2
3
4
5
6
7
8
    public Teacher(String firstName, String lastName, int age, int section) {
        // 构造对象中的 Person 部分
        super(firstName, lastName, age);
        // 我们保存所属系
        this.section = section;
        // 跟踪
        IO.println("Constructor Teacher(String, String, int, int)");
    }

该构造函数接收四个参数([firstName]、[lastName]、[age]、 [section]),并使用语句[super(firstName, lastName, age);] (第 3 行)把其中三个([firstName]、[lastName]、[age])传递给它的父类,这里即类[Person]。我们知道这个类有一个构造函数 [Person(String, String, int)],它将用于使用传入的参数创建一个人。一旦 [Person] 部分构造完成,[Teacher]对象的构造就会通过执行构造函数的其余部分(第 5–7 行)继续进行。

总之,派生类的构造函数:

  • 通过[super(...)]向其父类传递父类构造自身所需的参数;
  • 使用其他参数初始化它自己的字段。

我们本来可以选择在类[Teacher] 的构造函数中直接初始化字段 [firstName]、[lastName] 和 [age],使用类似[this.firstName = firstName;] 的语句。这是不可能的,原因有二。首先,私有字段 [firstName]、[lastName] 和 [age] 只能被 [Person] 类的方法访问。所有其他对象,包括像本例中这样的派生类的对象,都必须通过公共(或受保护)成员来访问它们。如果类 [Person] 把这些字段声明为 protected(*[protected]*),情况就会不同:这样派生类就可以直接访问它们。此外,对象的 [Person] 部分无论如何都必须由 [Person] 类的构造函数来构造:如果没有调用[super(...)],编译器会插入对[super()] 的调用——即父类的无参构造函数。然而,类 [Person] 并没有这样的构造函数。如果删除[super(firstName, lastName, age);]语句,编译器会报告如下错误:

1
2
3
4
5
6
7
8
9
> java Main.java
.../Inheritance1/Teacher.java:6: error: constructor Person in class Person cannot be applied to given types;
    public Teacher(String firstName, String lastName, int age, int section) {
                                                                            ^
  required: String,String,int
  found:    no arguments
  reason: actual and formal argument lists differ in length
1 error
error: compilation failed

因此,使用父类的构造函数是正确的解决方案,也是标准做法:构造子对象时,先调用父对象的构造函数,然后完成子对象特有的初始化(在我们的示例中是[section] )。与[this(...)]一样,只有不使用正在构造的对象的语句才可以出现在对[super(...)] 的调用之前(自 Java 25 起;此前,[super(...)] 必须是第一条语句)。

4.2.3. 继承的方法

类 [Teacher] 没有定义名为[getIdentity] 的方法。因此,表达式[e.getIdentity()],其中[e] 是一名教师,指的是从类[Person] 继承的方法 [getIdentity]:它是公共的,通过继承成为 [Teacher] 类的公共方法。[Inheritance1] 文件夹中的测试程序[Main.java]如下:

void main() {
    // 一位教师
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    // 从 Person 类继承的 getIdentity 方法
    IO.println(e.getIdentity());
    // Teacher 类特有的 getSection 方法
    IO.println("section=" + e.getSection());
    // 一个人
    Person p = new Person("Jean", "Dupont", 30);
    // display 方法接收 Person 或其派生类的对象
    display(e);
    display(p);
    // 从 Object 类继承的 toString 方法
    IO.println(e.toString());
    IO.println(p.toString());
    IO.println("Number of persons created: " + Person.getNbPersons());
}

// 显示 p 的身份信息
void display(Person p) {
    IO.println(p.getIdentity());
}
  • 第 3 行:创建一名教师;
  • 第 5 行:显示教师的身份信息,它是通过从[Person]类继承的[getIdentity]方法获得的;
  • 第 7 行:[getSection]方法,为[Teacher]类所特有;
  • 第 11–12 行:先后以一名教师和一个人调用[display]方法(第 20–22 行)。我们将在下一段中回到这个问题;
  • 第 14–15 行:对这两个对象调用[toString]方法。我们同样会回到这个问题。

结果:

> java Main.java
Constructor Person(String, String, int)
Constructor Teacher(String, String, int, int)
[Lucile, Dumas, 56]
section=61
Constructor Person(String, String, int)
[Lucile, Dumas, 56]
[Jean, Dupont, 30]
Teacher@70325e14
Person@37ceb1df
Number of persons created: 2

我们可以看到:

  • [Person] 对象(结果的第 2 行)先于[Teacher] 对象(第 3 行)被构造;
  • [e.getIdentity()] 提供的是教师[Person]部分的身份信息,不含其所属教研组(第 4 行);
  • 人员计数器也把教师计算在内(第 11 行):教师也是人。

要获得教师的完整身份信息,类[Teacher] 必须定义它自己的[getIdentity]方法。文件夹 [Inheritance2]就是这样做的。

4.2.4. 多态

考虑一个类层次结构:C0 ← C1 ← C2 ← … ← Cn,其中 Ci ← Cj 表示类 Cj 派生自类 Ci。这意味着类 Cj 具有类 Ci 的所有特性,外加一些额外的特性。设 Oi 为类型 Ci 的对象。当 j > i 时,写[Oi = Oj] 是合法的。确实,通过继承,类 Cj 具有类 Ci 的所有特性,外加一些额外的特性。因此,类型 Cj 的对象 Oj 包含一个类型 Ci 的对象。操作[Oi = Oj] 使类型为 Ci 的变量 Oi 引用对象 Oj:通过它只能访问类 Ci 中定义的成员。

类 Ci 的变量 Oi 实际上不仅可以引用类 Ci 的对象,还可以引用从类 Ci 派生的任何对象,这一事实称为多态:变量引用不同类型对象的能力。

我们举个例子,来看上一个程序中的方法[display] :

1
2
3
void display(Person p) {
    IO.println(p.getIdentity());
}

我们既可以向它传递 [Person] ,也可以传递 [Teacher]:在后一种情况下,类型为 [Person] 的形式参数[p],接收到类型为[Teacher] 的值。由于类型 [Teacher]派生自类型 [Person],因此这是合法的。这里的[p.getIdentity()]语句执行的是 [Person] 类的[getIdentity] 方法,这是程序中唯一存在的方法:对于教师(结果的第 7 行),我们只得到其“Person”部分的身份信息。下面来看看当类 [Teacher] 拥有它自己的[getIdentity] 方法时会发生什么。

4.2.5. 方法重写和动态绑定

在[Inheritance2]文件夹中,[Person]类与[Inheritance1]文件夹中的相同,只多了一处:

    // 此人的身份信息:在 Teacher 类中重写的方法
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // 重写 Object 类的 toString 方法
    @Override
    public String toString() {
        return getIdentity();
    }
  • 第 6–10 行:对方法[toString]的重新定义,将在下一段中讨论。

在[Teacher]类中,[getIdentity]方法被重新定义如下:

// final 类:不能被派生
public final class Teacher extends Person {
    // Teacher 类特有的字段
    private int section;

    // 构造函数
    public Teacher(String firstName, String lastName, int age, int section) {
        super(firstName, lastName, age);
        this.section = section;
        IO.println("Constructor Teacher(String, String, int, int)");
    }

    // 所属系的 getter 和 setter
    public int getSection() {
        return section;
    }

    public void setSection(int section) {
        this.section = section;
    }

    // getIdentity 方法重写了父类的方法
    @Override
    public String getIdentity() {
        return "Teacher[" + super.getIdentity() + "," + section + "]";
    }
}
  • 第 23–26 行:方法 [getIdentity] 重写了父类中的同名方法;它具有相同的名称、相同的参数和相同的返回类型。它依靠其父类的方法 [getIdentity](写作[super.getIdentity()])来获取“Person”部分,然后补充类[Teacher]特有的教研组信息;
  • 第 23 行:注解[@Override] 告诉编译器该方法意在重写父类的方法。它不是强制的,但强烈建议使用:如果该方法没有重写任何东西(由于名称拼写错误或参数不同),编译器会报告错误,而不是悄悄创建一个新方法;
  • 第 2 行:该类是 final 的([final]),我们稍后会更详细地解释。

考虑一个教师对象[E]。这个对象内部包含一个[Person]对象:

Image

方法[getIdentity] 在类[Teacher] 及其父类[Person]中都有定义。在 Java 中,所有既不是 private 也不是 final 的实例方法都可以被重写,而[p.getIdentity()] 执行哪个方法是在运行时,根据[p]所引用对象的实际类型来决定的,而不是在编译时根据变量的声明类型来决定。这称为动态绑定。为了执行[o.m()],虚拟机按以下顺序查找名为[m] 的方法:

  • 在对象[o]的类中;
  • 如果有父类,则在其父类中;
  • 如果存在,则在其父类的父类中;
  • 依此类推。

因此,继承允许你在子类中重新定义与父类签名相同的方法。这使你能够让子类适应自己的需求。文件夹[Inheritance2] 中的程序[Main.java] 如下:

void main() {
    // 一位教师
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    display(e);
    // 一个人
    Person p = new Person("Jean", "Dupont", 30);
    display(p);
    // 即使被视为 Person,教师仍然是教师
    Person pe = e;
    IO.println(pe.getIdentity());
    IO.println(((Person) e).getIdentity());
    // IO.println(Object) 显示对象的 toString 方法的结果
    IO.println(e);
    IO.println(p);
    // 由不同类型的人员组成的数组
    Person[] persons = { p, e };
    for (Person person : persons) {
        IO.println(person.getClass().getSimpleName() + " : " + person);
    }
}

// 显示 p 的身份信息
void display(Person p) {
    IO.println(p.getIdentity());
}

结果:

> java Main.java
Constructor Person(String, String, int)
Constructor Teacher(String, String, int, int)
Teacher[[Lucile, Dumas, 56],61]
Constructor Person(String, String, int)
[Jean, Dupont, 30]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
[Jean, Dupont, 30]
Person : [Jean, Dupont, 30]
Teacher : Teacher[[Lucile, Dumas, 56],61]

这一次,在结果的第 4 行,[display]方法正确地显示了教师的全名。程序的第 9–11 行表明,无论是通过 [Person] 类型的变量来看,还是通过运算符[(Person)]转换为 [Person],教师仍然是教师:被执行的仍然是类[Teacher] 的[getIdentity] 方法(结果的第 7–8 行)。转换改变的是引用的类型,而不是对象的类型。与 C# 等其他语言中只有声明为 virtual 的方法才能被重写不同,Java 的方法默认就是“虚”的;Java 中不存在重写实例方法的例外。

4.2.6. Object 类和 toString 方法

类[java.lang.Object]是所有 Java 类的“父”类。因此,当你写[public class Person],你实际上隐式地写了[public class Person extends Object]。

类[Object]定义了所有对象都会继承的几个方法:

  • [String toString()]:返回对象的文本表示。默认情况下,它是对象的类名,后面跟着字符[@] 和一个以十六进制书写的哈希码;
  • [boolean equals(Object o)]:指示该对象是否与对象[o]“相等”。默认情况下,它只与自身相等:该方法像运算符[==]一样比较引用;
  • [int hashCode()]:返回对象的哈希码,供字典和集合使用(见下一章)。方法[equals] 和[hashCode] 将在后面讨论;
  • [Class<?> getClass()]:返回对象实际类的描述。该描述中的方法[getSimpleName] 返回类名,而[getName] 返回其完整名称。

在文件夹 [Inheritance1] 中,调用[e.toString()] 和[p.toString()] 使用的是类[Object] 的方法[toString] :[Teacher@70325e14] 和[Person@37ceb1df] (结果的第 9–10 行;这些数字在每次执行时都会变化)。尽管我们没有在类[Person] 和[Teacher]中重新定义方法[toString],类[Object] 中的[toString] 方法仍然能够显示对象的实际类名。

在 [Inheritance2] 文件夹中,[Person]类重新定义了[toString]方法(见上文)。让我们回到文件夹[Inheritance2]中的程序[Main.java]:

1
2
3
4
5
6
7
8
    // IO.println(Object) 显示对象的 toString 方法的结果
    IO.println(e);
    IO.println(p);
    // 由不同类型的人员组成的数组
    Person[] persons = { p, e };
    for (Person person : persons) {
        IO.println(person.getClass().getSimpleName() + " : " + person);
    }

第 2 行:[IO.println(Object)]方法接受[Object]类型的参数;因此,由于[Object] 是所有类的超类,任何对象(这里是[Teacher])都可以传入。它把对象的[toString]方法的结果输出到控制台。由于绑定是动态的,使用的是实际对象的[toString]方法——这里是从[Person]类继承的方法。它返回[getIdentity()],而这是一个被重新定义的方法:对于教师[e],因此会执行类 [Teacher] 的[getIdentity] 方法,如结果的第 9 行所示。因此无需在类[Teacher]中重新定义[toString] 。

同样的机制也适用于字符串与对象的连接:在 [" : " + person](第 7 行)中,对象[person] 通过其方法[toString]转换为字符串。第 6–8 行的循环遍历一个[Person] 引用数组,这些引用实际上指向不同类型的对象:[getClass().getSimpleName()] 返回每个对象的实际类名(结果的第 11–12 行)。

4.2.7. final 类和密封类

包[Inheritance2] 中的类 [Teacher] 被声明为[public final class Teacher extends Person]。关键字[final] 阻止从类[Teacher]派生其他类:声明[class TeacherResearcher extends Teacher] 会被编译器拒绝。当一个类不打算被派生时,就把它标记为 final。我们已经看到该关键字也适用于方法:[final] 方法 不能被派生类重写,但并不禁止从该类派生。例如,JDK 中的类[String],就是 final 的。

在对所有派生开放的类与 final 类之间,Java 17 增加了一个中间选项:密封类([sealed]),它给出其直接派生类的完整列表。程序[Classes13.java] 对此进行了说明:

// final 类和密封类(Java 17)
void main() {
    Person[] persons = {
        new Teacher("Lucile", "Dumas", 61),
        new Student("Paul", "Martin", "computer science"),
        new Adjunct("Marc", "Petit"),
        new Consultant("Lise", "Morel", "Airbus"),
    };
    for (Person p : persons) {
        IO.println(p.getClass().getSimpleName() + " : " + p.getIdentity());
    }
    // 密封类 Person 允许的直接子类
    IO.println("Person is sealed: " + Person.class.isSealed());
    for (Class<?> c : Person.class.getPermittedSubclasses()) {
        IO.println("permitted subclass: " + c.getSimpleName());
    }
}

// 密封类:只有 permits 之后列出的类才能派生它
abstract sealed class Person permits Teacher, Student, Adjunct {
    private final String firstName;
    private final String lastName;

    protected Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getIdentity() {
        return "[" + firstName + ", " + lastName + "]";
    }
}

// 从密封类派生的类必须是 final、sealed 或 non-sealed
final class Teacher extends Person {
    private final int section;

    public Teacher(String firstName, String lastName, int section) {
        super(firstName, lastName);
        this.section = section;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", section " + section;
    }
}

final class Student extends Person {
    private final String major;

    public Student(String firstName, String lastName, String major) {
        super(firstName, lastName);
        this.major = major;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", major " + major;
    }
}

// non-sealed:从这个类开始,层次结构重新开放
non-sealed class Adjunct extends Person {
    public Adjunct(String firstName, String lastName) {
        super(firstName, lastName);
    }
}

// 从 Adjunct 派生的类:允许,因为 Adjunct 不是密封的
class Consultant extends Adjunct {
    private final String company;

    public Consultant(String firstName, String lastName, String company) {
        super(firstName, lastName);
        this.company = company;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", company " + company;
    }
}

// 被编译器拒绝:Artist 没有列在 Person 的 permits 子句中
// final class Artist extends Person { ... }
  • 第 20 行:抽象类(见下文:不能创建该类的对象,只能创建其派生类的对象)[Person] 是密封的。只有在关键字[permits]之后列出的类[Teacher]、[Student] 和 [Adjunct]才能从它派生。当派生类像这里一样声明在同一个文件中时,[permits]子句可以省略:此时被授权的类就是该文件中直接从它派生的类。在较大的程序中,被授权的类必须与密封类属于同一个包(如果密封类属于具名模块,则属于同一个模块);
  • 第 24 行:构造函数是受保护的([protected]):它仅供派生类使用;
  • 第 35 行和第 49 行:从密封类派生的类必须指明它自身可以如何被派生。类[Teacher] 和[Student] 是 final 的;
  • 第 64 行:类[Adjunct] 被声明为[non-sealed]:这会重新开放层次结构,允许任何类从它派生。第三种选择是把它本身声明为[sealed],并给出它自己的许可类列表;
  • 第 71–83 行:类[Consultant] 派生自[Adjunct],这是允许的;
  • 第 85–86 行:从[Person] 派生的类[Artist] 会被拒绝;
  • 第 13–16 行:类的描述([Person.class])表明它是否是密封的([isSealed]),并列出其被授权的直接派生类([getPermittedSubclasses])。

结果:

1
2
3
4
5
6
7
8
9
> java Classes13.java
Teacher : [Lucile, Dumas], section 61
Student : [Paul, Martin], major computer science
Adjunct : [Marc, Petit]
Consultant : [Lise, Morel], company Airbus
Person is sealed: true
permitted subclass: Teacher
permitted subclass: Student
permitted subclass: Adjunct

如果取消类[Artist] 的注释(并为其提供一个构造函数),编译器会报告:

1
2
3
4
5
6
> java Classes13.java
Classes13.java:86: error: class is not allowed to extend sealed class: Classes13.Person (as it is not listed in its 'permits' clause)
final class Artist extends Person { Artist() { super("a", "b"); } }
      ^
1 error
error: compilation failed

密封类有什么用?它使类层次结构的作者能够保持对层次结构的控制:作者知道任何[Person] 要么是[Teacher],要么是[Student],要么是[Adjunct]。编译器同样知道这一点,并在模式过滤中加以利用,这将在本章末尾讨论:处理这三种情况的[switch] 是完备的。该机制也适用于接口([sealed interface]),稍后会讨论。

4.3. 没有运算符重载:equals、compareTo……

某些语言(例如 C# 或 C++)允许你为类重新定义运算符([+]、[==]、[<]……)的含义。Java 不允许这样做:运算符始终具有语言赋予它们的含义。唯一的例外是应用于字符串的[+]运算符,它执行连接操作,并使用被连接对象的[toString]方法来完成。我们不使用运算符,而是编写遵循既定约定的方法:

操作
Java 方法
示例
内容相等([==] 比较的是引用)
[boolean equals(Object o)],继承自[Object]
[s1.equals(s2)]
比较([<]、[>]……)
来自[Comparable<T>]接口的 [int compareTo(T other)] :结果为负数、零或正数
[s1.compareTo(s2) < 0]
算术运算
显式命名的方法
[a.add(b)]、[a.multiply(b)] ,用于[BigDecimal]
向集合中添加([+=])
[add]
[list.add(p)]

4.3.1. 一个示例

文件夹[Lists] 包含一个类[ListOfPersons],即人员列表,其方法起着运算符[+] 和[+=]的作用。该文件夹中的类[Person] 和[Teacher] 是[Inheritance2]文件夹中对应类的简化版本:字段是[final] 的,没有修改器;也不再有任何跟踪消息或计数器。这些人被组织在一个泛型列表 [List<Person>] 中(泛型类将在本章后面讨论;列表将在下一章介绍)。我们不让类 [ListOfPersons] 继承JDK 中的某个列表类,而是把列表放在该类的私有字段中。这称为使用组合而不是继承:这样类 [ListOfPersons]只暴露它所选择的操作。对于接口[List<Person>],我们只使用以下元素:

  • 方法[l.add(p)],它把人员[p] 添加到列表[l]中,以及[l.addAll(l2)]方法,它把[l2]列表中的所有元素添加到其中;
  • 方法[l.size()],它返回列表[l]中的元素个数;
  • 方法[l.get(i)] 和[l.set(i, p)],它们读取和修改列表[l]的第 i 个元素。

类[ListOfPersons] 的定义如下:[ListOfPersons.java]:

import java.util.ArrayList;
import java.util.List;
import java.util.StringJoiner;

public class ListOfPersons {
    // 列表中的人员
    private final List<Person> persons = new ArrayList<>();

    // 列表中的人数
    public int size() {
        return persons.size();
    }

    // 相当于 + 运算符:返回一个新列表,包含当前列表的人员
    // 和人员 p
    public ListOfPersons plus(Person p) {
        ListOfPersons result = new ListOfPersons();
        result.persons.addAll(persons);
        result.persons.add(p);
        return result;
    }

    // 相当于 += 运算符:将 p 添加到当前列表并返回该列表
    public ListOfPersons add(Person p) {
        persons.add(p);
        return this;
    }

    // 相当于索引器:读取和写入第 i 个元素
    public Person get(int i) {
        return persons.get(i);
    }

    public void set(int i, Person p) {
        persons.set(i, p);
    }

    // 具有给定姓氏的人员的位置,不存在则为 -1
    public int indexOf(String lastName) {
        for (int i = 0; i < persons.size(); i++) {
            if (persons.get(i).getLastName().equals(lastName)) {
                return i;
            }
        }
        return -1;
    }

    // toString:返回 (person1,person2,...)
    @Override
    public String toString() {
        StringJoiner joiner = new StringJoiner(",", "(", ")");
        for (Person p : persons) {
            joiner.add(p.toString());
        }
        return joiner.toString();
    }
}
  • 第 1–3 行:与紧凑文件[Main.java]不同,常规文件不会自动导入[java.base]模块中的类:它必须导入自己所使用的类([java.lang]包中的类除外,例如[String],它们始终是已知的)。[import]子句随包一起提供;
  • 第 7 行:人员列表。关键字[final] 表示该字段始终引用同一个列表;列表本身的内容可以改变。[new ArrayList<>()] 创建一个空列表;“菱形”运算符[<>] 使编译器能够根据字段类型推断元素的类型[Person],;
  • 第 10–12 行:人员数量;
  • 第 16–21 行:方法[plus] 对于操作[+]起着运算符的作用[l.plus(p)],其中[l] 的类型是 [ListOfPersons],而 [p] 的类型是[Person] 或其派生类型。它创建一个新列表(第 17 行),把当前列表中的人员复制到其中(第 18 行),然后添加人员[p] (第 19 行)。与数字或字符串的[+]运算符一样,操作数不会被修改。由于列表[result] 属于同一个类,该方法可以访问其私有字段[result.persons]。返回的列表类型是[ListOfPersons],这使得可以像[l.plus(p1).plus(p2)]那样进行链式调用;
  • 第 24–27 行:方法[add] 起着[+=]运算符的作用:它通过向当前列表添加人员[p]来修改当前列表,并返回同一个列表,这同样允许链式调用;
  • 第 49–56 行:我们重新定义[toString]方法,以 (person1, person2, ...) 的形式显示人员列表,其中 personi 本身就是该人员的[toString]方法的结果。[StringJoiner]对象(第 51 行)由连续的元素([add],第 53 行)构造字符串,用指定的分隔符(这里是逗号)分隔它们,并用前缀和后缀(这里是圆括号)括起来。

请注意,类[ListOfPersons] 没有构造函数。因此它使用默认构造函数,该构造函数不接受参数,除了用声明中指定的值初始化字段[persons] 之外什么也不做。第 29–46 行将在下一节讨论。

测试程序[Main.java] 开头如下:

void main() {
    // —— 用方法代替运算符
    String s1 = "jean";
    String s2 = new StringBuilder("je").append("an").toString();
    IO.println("s1 == s2 : " + (s1 == s2) + ", s1.equals(s2) : " + s1.equals(s2));
    IO.println("s1.compareTo(\"paul\") : " + s1.compareTo("paul"));
    BigDecimal a = new BigDecimal("0.10"), b = new BigDecimal("0.20");
    IO.println("a + b = " + a.add(b) + ", a < b : " + (a.compareTo(b) < 0));

    // —— plus 方法
    // 人员列表
    ListOfPersons l = new ListOfPersons();
    // 添加人员
    l = l.plus(new Person("jean", "martin", 10)).plus(new Person("pauline", "leduc", 12));
    // 显示
    IO.println("l=" + l);
    // l.plus(p) 返回一个新列表:l 不会被修改
    ListOfPersons l2 = l.plus(new Person("louis", "durand", 8));
    IO.println("l=" + l);
    IO.println("l2=" + l2);

    // —— add 方法
    ListOfPersons l3 = l;
    // add 修改 l 所引用的列表,而不创建新列表
    l.add(new Teacher("camille", "germain", 27, 60));
    IO.println("l=" + l);
    // l 和 l3 仍然引用同一个对象
    IO.println("l3 == l : " + (l3 == l));
  • 第 3–5 行:两个内容相同但互不相同的字符串:字符串[s2] 是在运行时构造的。运算符[==] 比较引用,而方法[equals]比较内容。要比较两个字符串,必须始终使用[equals];
  • 第 6 行:方法[compareTo] 返回一个负数,因为按字符编码顺序,“jean”排在“paul”之前;
  • 第 7–8 行:类[BigDecimal](精确的十进制数,我们将用它表示金额)用方法[add] 和[compareTo] 取代了运算符[+] 和[<];
  • 第 12 行:创建一个空的人员列表[l];
  • 第 14 行:使用[plus]方法添加两个人;
  • 第 18 行:[l.plus(p)] 创建一个新列表[l2];列表[l] 保持不变;
  • 第 25 行:使用[add]方法添加一名教师;
  • 第 16–20 行:字符串与对象的连接使用[toString]方法,该方法在[ListOfPersons]类中被重新定义。

结果(开头):

1
2
3
4
5
6
7
8
9
> java Main.java
s1 == s2 : false, s1.equals(s2) : true
s1.compareTo("paul") : -6
a + b = 0.30, a < b : true
l=([jean, martin, 10],[pauline, leduc, 12])
l=([jean, martin, 10],[pauline, leduc, 12])
l2=([jean, martin, 10],[pauline, leduc, 12],[louis, durand, 8])
l=([jean, martin, 10],[pauline, leduc, 12],Teacher[[camille, germain, 27],60])
l3 == l : true

既然[l = l.plus(p)] 与[l.add(p)]产生相同的输出,为什么还有两个方法呢?[plus]方法创建一个新列表,把[l]中的所有人员复制到其中,然后[l] 引用这个新列表,而旧列表由垃圾回收器丢弃。方法[add] 把人员添加到现有列表中,而不进行复制。第 23 行保存了对列表[l3],的第二个引用[l];在调用[l.add(...)]之后,两个引用仍然指向同一个对象(结果的第 9 行),这证明列表没有被重新创建。对于大型列表或在循环中,性能差异是显著的。这两种风格的选择在 JDK 中清晰可见:不可变对象[String] 和[BigDecimal] 返回新对象;列表和[StringBuilder] 则被就地修改。

4.4. 没有索引器:get 和 set 方法

这里,我们继续使用 [ListOfPersons] 类。如果[l] 是一个 [ListOfPersons] 对象,我们希望能够读取和写入[l]列表中索引为 i 的人员。某些语言允许为此定义“索引器”,从而可以在对象上使用[l[i]]这种写法。Java 不允许这样做:[[i]]写法是为数组保留的。按照惯例,我们像 JDK 列表那样编写方法[get(int i)] 和[set(int i, value)]:

    // 相当于索引器:读取和写入第 i 个元素
    public Person get(int i) {
        return persons.get(i);
    }

    public void set(int i, Person p) {
        persons.set(i, p);
    }

    // 具有给定姓氏的人员的位置,不存在则为 -1
    public int indexOf(String lastName) {
        for (int i = 0; i < persons.size(); i++) {
            if (persons.get(i).getLastName().equals(lastName)) {
                return i;
            }
        }
        return -1;
    }
  • 第 2–4 行:方法[get] 从私有列表[persons]中返回第 i 号人员;
  • 第 6–8 行:[set]方法把人员[p]赋给它;
  • 第 11–18 行:我们还希望能够获得具有给定姓名的人员在列表中的位置,如果该人员不在列表中则得到 -1。名称[indexOf] 与 JDK 中列表和字符串的对应方法相同。姓名使用[equals] 进行比较(第 13 行)。

测试程序继续如下:

    // —— 用 get、set 和 indexOf 方法代替索引器
    // 修改第 1 个元素
    l.set(1, new Person("franck", "gallon", 5));
    // 显示第 1 个元素
    IO.println("l.get(1)=" + l.get(1));
    // 显示列表 l
    IO.println("l=" + l);
    // 按姓氏搜索人员
    String[] lastNames = { "martin", "germain", "xx" };
    for (String lastName : lastNames) {
        int index = l.indexOf(lastName);
        if (index != -1) {
            IO.println("Person(" + lastName + ")=" + l.get(index));
        } else {
            IO.println("Person(" + lastName + ") does not exist");
        }
    }
  • 第 3 行:调用[set]方法;
  • 第 5 行:调用方法[get];
  • 第 11 行:调用方法[indexOf];
  • 第 13 行:调用方法[get]。

结果(结尾):

1
2
3
4
5
6
...
l.get(1)=[franck, gallon, 5]
l=([jean, martin, 10],[franck, gallon, 5],Teacher[[camille, germain, 27],60])
Person(martin)=[jean, martin, 10]
Person(germain)=Teacher[[camille, germain, 27],60]
Person(xx) does not exist

4.5. 没有结构体:基本类型和记录

4.5.1. 值与引用

其他语言(例如 C 或 C#)除了类之外还提供结构体:这种类型的变量直接包含数据,而不是对象的引用。Java 没有它们。它区分两大类类型:

  • 八种基本类型 ([byte]、[short]、[int]、[long]、[float]、[double]、[char]、[boolean]):基本类型的变量包含值本身;
  • 引用类型:类(包括[String])、接口、数组、记录等。引用类型的变量包含对对象的引用,例如[null]。

程序[Classes14.java] 说明了这种区别:

// 基本类型和引用类型:值的复制,引用的复制
void main() {
    // 两个基本类型的变量
    int age1 = 10;
    int age2 = age1;
    IO.println("age1=" + age1 + ", age2=" + age2);
    // age2 被修改
    age2 = 30;
    // 检查 age1 和 age2
    IO.println("age1=" + age1 + ", age2=" + age2);

    // 对象 op1
    CPerson op1 = new CPerson();
    op1.name = "paul";
    op1.age = 10;
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    // 对象 op2
    CPerson op2 = op1;
    IO.println("op2=CPerson(" + op2.name + "," + op2.age + ")");
    // op2 被修改
    op2.name = "nicole";
    op2.age = 30;
    // 检查 op1 和 op2
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    IO.println("op2=CPerson(" + op2.name + "," + op2.age + ")");

    // 显式复制对象
    CPerson op3 = new CPerson();
    op3.name = op1.name;
    op3.age = op1.age;
    op3.age = 50;
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    IO.println("op3=CPerson(" + op3.name + "," + op3.age + ")");
}

// CPerson 类
class CPerson {
    String name = "";
    int age;
}
  • 第 37–40 行:一个具有两个可从包内访问的字段的类:[name], [age]。非私有字段——通常不被提倡——使这里的示例更易阅读。

结果:

1
2
3
4
5
6
7
8
9
> java Classes14.java
age1=10, age2=10
age1=10, age2=30
op1=CPerson(paul,10)
op2=CPerson(paul,10)
op1=CPerson(nicole,30)
op2=CPerson(nicole,30)
op1=CPerson(nicole,30)
op3=CPerson(nicole,50)

声明[int age1 = 10;] (第 4 行)保留了一个包含整数 10 的内存位置:[age1] 的值就是整数本身。对于类,对象([name], [age])是使用运算符[new] 显式创建的(第 13 行)。对象被放置在由垃圾回收器管理的内存区域,即堆中,而[op1] 的值是这个对象的地址(引用)。

当程序中写下[int age2 = age1;](第 5 行)时,[age1]的值——整数 10——被复制到[age2]中:这是值复制。修改[age2] 不会修改[age1] (结果的第 3 行)。现在来看指令[CPerson op2 = op1;] (第 18 行)。[op1] 的值被复制到[op2],但由于这个值是对象的地址,对象本身并没有被复制:[op1] 和[op2] 引用同一个对象。如果[op2]所指向的对象被修改,那么[op1] 所指向的对象也会被修改,因为它们是同一个对象(结果的第 6–7 行)。要获得第二个对象,必须创建它并把第一个对象的字段复制到其中(第 28–30 行):修改副本不会修改原件(结果的第 8–9 行)。

Image

从这些说明中,我们可以得出结论:

  • 基本类型变量的值就是数据本身;
  • 引用类型变量的值是它所指向对象的地址;
  • 赋值和参数传递始终复制变量的值:对基本类型而言复制的是数据本身,对对象而言复制的是引用。

每种基本类型都对应[java.lang]包中一个所谓的“包装”类:[Integer] 对应[int],[Double] 对应[double],[Boolean] 对应[boolean],依此类推。编译器会自动在基本值与包装对象之间相互转换(“自动装箱”和“拆箱”):在使用只接受引用类型的泛型时我们会需要这一点。[Integer] 类型的变量可以等于[null],但[int] 类型的变量永远不可能。

为了表示作为值来处理的小型复合数据(点、颜色、日期、金额),Java 使用不可变类:它们的对象在创建之后不能被修改。共享对不可变对象的引用是安全的:没有人能够修改它,因此该对象表现得像一个值。有两个工具完善了这套体系:*[equals]* 方法,它根据内容比较两个对象;以及记录,它用一行代码就声明一个不可变类。这是接下来两段的主题。

4.5.2. 两个对象的相等:equals 和 hashCode

正如我们所见,应用于两个引用的[==]运算符表示它们是否引用同一个对象,而继承自[equals]的[Object] 的方法所做的也是一样的事。要使内容相同的两个不同对象被视为相等,类必须重新定义方法[equals],并且必须同时重新定义方法[hashCode]。程序[Classes15.java] 演示了这一点:

// 两个对象的相等性:equals 和 hashCode
void main() {
    Person p1 = new Person("paul", 10);
    Person p2 = new Person("paul", 10);
    Person p3 = new Person("nicole", 30);
    // == 比较引用,equals 比较值
    IO.println("p1 == p2 : " + (p1 == p2) + ", p1.equals(p2) : " + p1.equals(p2)
            + ", p1.equals(p3) : " + p1.equals(p3));
    // 两个相等的对象具有相同的哈希码
    IO.println("p1.hashCode() == p2.hashCode() : " + (p1.hashCode() == p2.hashCode()));
    // 集合(Set)不包含两个相等的对象
    Set<Person> persons = new HashSet<>();
    persons.add(p1);
    persons.add(p2);
    persons.add(p3);
    IO.println("size of the set: " + persons.size());
    IO.println("the set contains (paul,10): " + persons.contains(new Person("paul", 10)));
}

class Person {
    // 字段
    private final String name;
    private final int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 如果姓名和年龄相同,则两个人相等
    @Override
    public boolean equals(Object o) {
        // 是同一个对象吗?
        if (this == o) {
            return true;
        }
        // o 是 Person(且不为 null)吗?
        if (!(o instanceof Person other)) {
            return false;
        }
        // 比较各字段
        return age == other.age && Objects.equals(name, other.name);
    }

    // 与 equals 一致的哈希码
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person(" + name + "," + age + ")";
    }
}
  • 第 32–44 行:方法[equals] 重写了类[Object]的该方法。它的参数类型是[Object]:一个人可以与任何对象比较。该方法遵循一种标准模式:
    • 第 35–37 行:对象等于它自身;
    • 第 39–41 行:表达式[o instanceof Person other] (Java 16)在[o] 引用 [Person] 类型(或其派生类)的对象时为真,否则为假,特别是当[o] 等于[null]时。当它为真时,类型为[other],[Person],的变量引用对象[o]:可以使用它的字段。这种“类型模式”将在本章末尾详细解释;
    • 第 43 行:比较各字段。方法[Objects.equals(a, b)] 使用[equals] 比较两个对象,并处理其中之一为[null]的情况;
  • 第 47–50 行:方法[hashCode] 返回根据相同字段计算出的整数,这里由方法[Objects.hash]计算。这条规则是强制性的:按[equals] 的意义相等的两个对象必须具有相同的哈希码。JDK 中的字典和集合(下一章)依据这个码来组织对象,如果不遵守该规则,它们将无法正常工作;
  • 第 12–17 行:[HashSet]集合永远不会包含两个相等的对象:添加与[p2]相等的[p1]没有任何效果,而对新人员([paul, 10])的查找是成功的。

结果:

1
2
3
4
5
> java Classes15.java
p1 == p2 : false, p1.equals(p2) : true, p1.equals(p3) : false
p1.hashCode() == p2.hashCode() : true
size of the set: 2
the set contains (paul,10): true

手工编写[equals] 和[hashCode] 既繁琐又容易出错;开发环境可以生成它们。而记录则会自动提供它们。

4.5.3. 不可变对象

程序[Classes16.java] 演示了定义不可变数据的两种方式:

// 不可变对象:不可变类和记录
void main() {
    Point a = new Point(1, 2);
    // a.x = 5;   // 被拒绝:x 字段是 final
    Point b = a.move(3, 4);
    IO.println("a=" + a + ", b=" + b);

    // 记录:构造函数、访问器、toString、equals 和 hashCode 都是自动生成的
    Color red = new Color(255, 0, 0);
    Color red2 = new Color(255, 0, 0);
    IO.println("red=" + red + ", r=" + red.r());
    IO.println("red.equals(red2) : " + red.equals(red2) + ", red == red2 : " + (red == red2));
    // 用手写方法创建的修改后副本
    Color pink = red.withG(128).withB(128);
    IO.println("red=" + red + ", pink=" + pink);
}

// 不可变类:final,私有且 final 的字段,没有 setter
final class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    // 我们不修改该点:而是返回一个新的点
    public Point move(int dx, int dy) {
        return new Point(x + dx, y + dy);
    }

    @Override
    public String toString() {
        return "(" + x + "," + y + ")";
    }
}

// 记录:一行声明的不可变类……或者差不多
record Color(int r, int g, int b) {
    // 返回修改后记录副本的方法
    public Color withG(int g) {
        return new Color(r, g, b);
    }

    public Color withB(int b) {
        return new Color(r, g, b);
    }
}
  • 第 19–45 行:手工编写的不可变类。它是 final 的,因此任何派生类都不能为它添加可变状态;它的字段是私有的并且是[final]的;它没有修改器。为了“移动”一个点,方法[move] 返回一个新的点(第 37–39 行);
  • 第 48 行:一个记录 (Java 16)。头部[record Color(int r, int g, int b)] 声明了一个 final 类,它有三个私有字段——[final],称为记录的组件——一个三参数构造函数,以及三个访问器:[r()]、[g()], [b()],还有方法[toString]、[equals]和[hashCode],它们全都使用这些组件;
  • 第 50–56 行:可以向记录添加方法。由于记录是不可变的,不能被修改:因此要创建一个副本,其中某个组件已被更改。这些方法称为“wither”(来自英语的“with”);其他语言为此提供了表达式[with],它在 Java 25 中并不存在;
  • 第 11 行:组件的访问器以组件命名,不带前缀[get];
  • 第 12 行:具有相同组件的两个记录在[equals]的意义上是相等的,尽管它们是不同的对象;
  • 第 14 行:“wither”方法被链接在一起。

结果:

1
2
3
4
5
> java Classes16.java
a=(1,2), b=(4,6)
red=Color[r=255, g=0, b=0], r=255
red.equals(red2) : true, red == red2 : false
red=Color[r=255, g=0, b=0], pink=Color[r=255, g=128, b=128]

生成的[toString] 显示记录名称及其组件(结果的第 3 行)。请注意,记录是声明小型不可变数据最简洁的方式:本章示例应用程序中的税率档就将使用这种类型。记录将在后面详细讨论。

4.6. 接口

4.6.1. 第一个示例

接口是一组构成契约的方法声明。选择实现接口的类承诺为接口中定义的所有抽象方法提供实现。编译器会验证这一实现。

例如,下面是 JDK 的[java.util.Iterator<E>]接口的(简化)定义,它允许你遍历集合中的元素:[public interface Iterator<E> { boolean hasNext(); E next(); }]。接口的方法仅由其签名定义,后面跟一个分号:它们没有代码,并且隐式地是 public 和 abstract 的。为接口方法提供代码的是实现该接口的类。名为[C] 的类使用关键字[implements]声明它实现该接口:[public class C implements Iterator<String>],然后它必须定义两个公共方法[public boolean hasNext() { ... }] 和[public String next() { ... }]。

一种常见的约定(尽管并不通用——JDK 就没有遵循)是以字母 I 开头来命名接口。下面的示例构成了[Statistics]文件夹。请看下面的接口[IStats.java]:

1
2
3
4
5
6
7
public interface IStats {
    // 一组值的平均值
    double average();

    // 这组值的标准差
    double standardDeviation();
}

接口[IStats]包含:

  • 一个方法[average]:用于计算一系列值的平均值;
  • 一个方法[standardDeviation]:用于计算标准差。

请注意,这里没有任何地方指明所指的是哪一组值。它可以是一个班级的平均成绩、某种产品的月平均销量、某个地点的平均气温……这正是接口的原理:我们假定对象中存在某些方法,而不假定存在特定的数据。这些方法没有前缀[get]:它们是计算而不是字段访问,这一选择将使记录能够实现该接口。

实现[IStats]接口的第一个类可以是用来存储班级学生某一科目成绩的类。学生由下面的[Student]记录来表示,[Student.java]:

1
2
3
// 一名学生
public record Student(String firstName, String lastName) {
}

学生由其名和姓来标识。上一段中所示的记录用一行代码就做到了这一点。成绩由下面的记录[Grade]表示,它如下[Grade.java]:

1
2
3
4
5
6
7
// 一名学生的成绩
public record Grade(Student student, double value) {
    @Override
    public String toString() {
        return "[" + student.firstName() + "," + student.lastName() + "," + value + "]";
    }
}

成绩由被评分的学生和成绩本身定义。该记录重新定义了编译器生成的[toString] 方法,以 [firstName,lastName,value] 的形式显示成绩。

某一科目所有学生的成绩被归入下面的类[ArrayOfGrades]:[ArrayOfGrades.java]:

import java.util.Arrays;

public class ArrayOfGrades implements IStats {
    // 字段
    private final String subject;
    private final Grade[] grades;
    private final double average;
    private final double standardDeviation;

    // 构造函数
    public ArrayOfGrades(String subject, Grade[] grades) {
        // 存储数据
        this.subject = subject;
        this.grades = grades;
        // 计算成绩的平均值
        double sum = 0;
        for (Grade grade : grades) {
            sum += grade.value();
        }
        average = grades.length != 0 ? sum / grades.length : -1;
        // 计算标准差
        double squares = 0;
        for (Grade grade : grades) {
            squares += Math.pow(grade.value() - average, 2);
        }
        standardDeviation = grades.length != 0 ? Math.sqrt(squares / grades.length) : -1;
    }

    // getter
    public String getSubject() {
        return subject;
    }

    public Grade[] getGrades() {
        return grades;
    }

    // IStats 接口方法的实现
    @Override
    public double average() {
        return average;
    }

    @Override
    public double standardDeviation() {
        return standardDeviation;
    }

    // toString
    @Override
    public String toString() {
        return "subject=" + subject + ", grades=" + Arrays.toString(grades);
    }
}
  • 第 3 行:类[ArrayOfGrades] 实现了接口[IStats]。因此它必须实现方法[average] 和[standardDeviation]。它们在第 39–47 行实现。注解[@Override] 同样用于实现接口方法;
  • 第 5–8 行:四个[final]字段:该对象存储成绩所属的科目、成绩数组、平均值以及成绩的标准差;
  • 第 11–27 行:构造函数。这里我们假定传给构造函数的成绩之后不会改变。因此,我们在构造函数中立即计算这些成绩的平均值和标准差并存储起来。像[final] 字段,例如[average],可以在构造函数中被赋值(第 20 行);此后不能再赋值。表达式[condition ? value1 : value2] 把空数组的平均值和标准差设为 -1。[Math.pow(x, 2)] 计算 x²,而[Math.sqrt] 计算平方根;
  • 第 50–53 行:方法[toString] 使用静态方法[Arrays.toString],它把数组的元素放在方括号中返回,以逗号分隔,每个元素都通过其[toString]方法转换为字符串,这里使用的是记录[Grade]的该方法。

在前面的类中,成绩存储在数组里。在[ArrayOfGrades]对象创建之后,不可能再添加新的成绩。现在我们提出[IStats]接口的第二种实现,称为[ListOfGrades],这一次成绩存储在[List<Grade>]列表中,并且可以在[ListOfGrades] 对象初次创建之后添加成绩:[ListOfGrades.java]:

import java.util.List;

public class ListOfGrades implements IStats {
    // 字段
    private final String subject;
    private final List<Grade> grades;
    // 存储的平均值和标准差(null:尚未计算)
    private Double average;
    private Double standardDeviation;

    // 构造函数
    public ListOfGrades(String subject, List<Grade> grades) {
        this.subject = subject;
        this.grades = grades;
    }

    // getter
    public String getSubject() {
        return subject;
    }

    public List<Grade> getGrades() {
        return grades;
    }

    // 添加一个成绩
    public void add(Grade grade) {
        grades.add(grade);
        // 平均值和标准差将需要重新计算
        average = null;
        standardDeviation = null;
    }

    // 成绩的平均值:首次请求时计算
    @Override
    public double average() {
        if (average == null) {
            average = computeAverage();
        }
        return average;
    }

    // 成绩的标准差:首次请求时计算
    @Override
    public double standardDeviation() {
        if (standardDeviation == null) {
            standardDeviation = computeStandardDeviation();
        }
        return standardDeviation;
    }

    private double computeAverage() {
        if (grades.isEmpty()) {
            return -1;
        }
        double sum = 0;
        for (Grade grade : grades) {
            sum += grade.value();
        }
        return sum / grades.size();
    }

    private double computeStandardDeviation() {
        if (grades.isEmpty()) {
            return -1;
        }
        double m = average();
        double squares = 0;
        for (Grade grade : grades) {
            squares += Math.pow(grade.value() - m, 2);
        }
        return Math.sqrt(squares / grades.size());
    }

    // toString
    @Override
    public String toString() {
        return "subject=" + subject + ", grades=" + grades;
    }
}
  • 第 3 行:类[ListOfGrades] 实现了接口[IStats];
  • 第 6 行:成绩现在存储在列表而不是数组中;
  • 第 27–32 行:现在可以在已存储的成绩之外再添加一个成绩。平均值和标准差不再在构造函数中计算,而是在接口方法本身中按需计算:[average] (第 35–41 行)和[standardDeviation] (第 44–50 行)。这些值一旦计算出来就会被存储,因此不会在每次请求时重新计算:这称为被缓存。添加成绩会使缓存失效;
  • 第 8–9 行:缓存。类型[Double] 是基本类型[double]的包装类:与[double]变量不同,[Double]变量可以取值[null],这里它表示“尚未计算”。未初始化的字段在对象构造时被设为[null] ;
  • 第 38 行和第 40 行:编译器自动把[computeAverage] 返回的[double] 转换为对象[Double] (“自动装箱”),并在作为方法返回值时把对象[Double] 转换为[double] (“拆箱”)。

测试程序可能如下[Main.java]所示:

void main() {
    // 几名学生及其英语成绩
    Student[] students = {
        new Student("Paul", "Martin"), new Student("Maxime", "Germain"), new Student("Berthine", "Samin")
    };
    Grade[] grades = { new Grade(students[0], 14), new Grade(students[1], 16), new Grade(students[2], 18) };
    // 它们存储在 ArrayOfGrades 对象中
    ArrayOfGrades english = new ArrayOfGrades("english", grades);
    // 显示平均值和标准差
    displayStats(english);
    // 同样的成绩放在 ListOfGrades 对象中
    ListOfGrades french = new ListOfGrades("french", new ArrayList<>(List.of(grades)));
    displayStats(french);
    // 我们添加一个成绩
    french.add(new Grade(new Student("Jérôme", "Jaric"), 10));
    displayStats(french);
    // 变量的类型可以是接口
    IStats stats = english;
    IO.println("English average: " + stats.average());
    stats = french;
    IO.println("French average: " + stats.average());
}

// 显示实现 IStats 的对象的平均值和标准差
void displayStats(IStats values) {
    IO.println(values + ", Average=" + values.average() + ", Standard deviation=" + values.standardDeviation());
}
  • 第 3–5 行:创建学生数组;
  • 第 6 行:创建成绩数组;
  • 第 8 行:一个[ArrayOfGrades]对象,其平均值和标准差在第 10 行显示;
  • 第 12 行:一个[ListOfGrades]对象,其平均值和标准差在第 13 行显示。[List.of(grades)] 返回由数组元素组成的只读列表;[ArrayList]类的构造函数把它变成可修改的列表,从而可以向其中添加成绩;
  • 第 15 行:添加一个新成绩,然后刷新显示;
  • 第 25–27 行:方法 [displayStats] 接受一个 *[IStats] 类型的参数,这是一个接口类型。这意味着实参可以是任何实现了 *[IStats] 接口的对象。使用接口类型的数据对象时,只会用到该数据对象所实现的接口方法,其余的都被忽略。这一特性类似于针对类所讨论的多态。如果一组彼此之间没有继承关系的类 Ci(因此无法使用基于继承的多态)共享一组具有相同签名的方法,那么把这些方法归入一个接口 I,由所有相关的类来实现它,可能会很有用。这些类 Ci 的实例随后就可以用作接受类型为 I 的形式参数的方法的实参——也就是说,这些方法只使用 Ci 对象中由接口 I 定义的方法,而不使用各个 Ci 类特有的字段和方法;
  • 第 18–21 行:变量可以是接口类型。这样它就可以引用实现了该接口的任何类的对象。编译器只允许访问接口的方法(以及类[Object]的方法,例如[toString])。

结果:

1
2
3
4
5
6
> java Main.java
subject=english, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=french, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=french, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0], [Jérôme,Jaric,10.0]], Average=14.5, Standard deviation=2.958039891549808
English average: 16.0
French average: 14.5

把数字([double])与字符串连接时使用[Double.toString]方法,该方法无论工作站的语言设置如何,始终以小数点和至少一位小数来书写数字(16.0)。要获得法式显示,请使用[String.format("%.2f", x)],如下面的示例所示。

最后请注意,接口可以被多次实现;也就是说,可以写[public class DerivedClass extends BaseClass implements I1, I2, ..., In],其中 Ij 是接口:一个类只能继承一个类,但可以实现任意多个接口。接口本身可以扩展一个或多个其他接口:[interface I3 extends I1, I2]。

4.6.2. 接口的默认方法、静态方法和私有方法

自 Java 8 起,接口可以为其部分方法提供默认实现,用关键字[default]声明。实现该接口的类随后可以使用这个实现,也可以提供自己的实现。这尤其使得可以向已发布的接口添加方法,而无需修改所有实现它的类:JDK 中的集合就是这样在历次版本中不断扩充的。接口还可以包含静态方法(Java 8)和私有方法(Java 9)。程序[Classes17.java] 提供了一个示例:

// 接口的 default(Java 8)、static(Java 8)和 private(Java 9)方法
void main() {
    IShape[] shapes = { new Square(2), new Circle(1), IShape.unitSquare() };
    for (IShape shape : shapes) {
        IO.println(shape.description());
    }
    // default 方法被 Square 类继承
    Square square = new Square(3);
    IO.println(square.description());
}

interface IShape {
    // 抽象方法:需要实现
    double area();

    // 带默认实现的方法
    default String description() {
        return getClass().getSimpleName() + " with area " + format(area());
    }

    // 静态方法:用接口名调用
    static IShape unitSquare() {
        return new Square(1);
    }

    // 私有方法:只能被接口的方法使用
    private String format(double value) {
        return String.format("%.2f", value);
    }
}

// Square 使用 description 的默认实现
// (静态类,因为接口创建正方形:参见 Classes10)
static class Square implements IShape {
    private final double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double area() {
        return side * side;
    }
}

// Circle 提供自己的 description 实现
class Circle implements IShape {
    private final double radius;

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

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    @Override
    public String description() {
        return String.format("Circle with radius %s and area %.2f", radius, area());
    }
}
  • 第 12–30 行:[IShape]接口:
    • 第 14 行:待实现的抽象方法[area],;
    • 第 17–19 行:具有默认实现的方法[description] 。该方法可以使用接口的其他方法([area]、[format])以及[Object] 的方法([getClass]);
    • 第 22–24 行:静态方法,通过接口名调用:[IShape.unitSquare()] (第 3 行)。这是一个静态工厂方法;
    • 第 27–29 行:私有方法,只有接口的方法可以访问。[String.format("%.2f", value)] 按照系统区域设置的约定把数字格式化为两位小数——这里是法语的小数逗号;
  • 第 34–45 行:类[Square] 只实现[area];它默认使用方法[description] 。它被声明为[static] ,因为接口的静态方法[unitSquare] 要创建正方形(参见[Classes10.java]);
  • 第 48–64 行:类[Circle] 提供了它自己的方法[description]。格式[%s] 插入由[Double.toString] 转换为字符串的半径(“1.0”),而格式[%.2f] 插入保留两位小数的面积;
  • 第 9 行:默认方法与其他任何方法一样被 [Square] 类继承,可以在类型为[Square] 的变量上调用它。

结果:

1
2
3
4
5
> java Classes17.java
Square with area 4,00
Circle with radius 1.0 and area 3,14
Square with area 1,00
Square with area 9,00

一个类可以实现两个接口,而每个接口都提供了具有相同签名的默认方法:此时编译器要求该类重新定义该方法,即使这意味着要通过[I1.super.method()]调用两个版本之一。与抽象类不同,接口没有状态:它不能声明实例字段,只能声明常量(隐式地为[static final])。

4.7. 抽象类

抽象类是不能被实例化的类。必须创建可以被实例化的派生类。可以使用抽象类来重构类层次结构的代码。让我们来看下面这个构成文件夹[Users] 的示例 [User.java]:

public abstract class User {
    // 字段
    private final String login;
    private final String password;
    private final String role;

    // 构造函数
    @SuppressWarnings("this-escape")
    protected User(String login, String password) throws UnknownUserException {
        // 我们保存信息
        this.login = login;
        this.password = password;
        // 我们识别用户
        String role = identify();
        // 已识别?
        if (role == null) {
            throw new UnknownUserException("[" + login + "," + password + "]");
        }
        this.role = role;
    }

    // toString
    @Override
    public String toString() {
        return "User[" + login + "," + password + "," + role + "]";
    }

    // 识别:返回用户的角色,如果无法识别则返回 null
    protected abstract String identify();
}
  • 第 1 行:该类使用关键字[abstract]声明为抽象类;
  • 第 9–20 行:类[User]的构造函数。这个类存储 Web 应用程序用户的信息。应用程序有多种类型的用户,通过用户名和密码进行身份验证(第 3–4 行)。对于某些用户,这两项信息会与目录(LDAP)进行核对,对于另一些用户则与数据库核对,等等。构造函数是[protected]的:它供派生类的构造函数使用;
  • 第 11–12 行:存储身份验证信息;
  • 第 14 行:它们由方法[identify]进行验证。由于在这一层级并不知道识别方式,因此用关键字[abstract]把它声明为抽象的(第 29 行)。抽象方法没有方法体:派生类将提供方法体。拥有抽象方法的类本身必须声明为抽象类。方法 [identify] 返回一个指明用户角色的字符串(基本上就是他们被授权做什么),如果用户未被识别则返回[null] ;
  • 第 16–18 行:如果用户未被识别,则抛出异常。异常[UnknownUserException]是受检异常(见下文):构造函数必须使用[throws UnknownUserException] 子句声明它(第 9 行);
  • 第 23–26 行:方法[toString],它标识类的一个实例。

这里我们假定开发者想要控制类[User] 及其派生类的实例的创建,也许是因为他们希望确保在用户未被识别时抛出某种类型的异常。派生类可以依靠这个构造函数。为此,它们必须提供 [identify] 方法。请注意,这里的构造函数调用了一个被派生类重写的方法,尽管那些类尚未执行它们自己的构造函数:因此 [identify] 方法不得使用派生类的任何字段,因为它们尚未被初始化。这是一种应当谨慎使用的做法,当使用[-Xlint:all]选项编译(该选项会启用所有警告)时,编译器会对此发出提示(这里没有第 8 行的注解,因此消息中的行号是 13):

1
2
3
4
5
> javac -Xlint:all -d classes *.java
User.java:13: warning: [this-escape] possible 'this' escape before subclass is fully initialized
        String role = identify();
                              ^
1 warning

警告[this-escape] (Java 21)表明正在构造的对象([this])在完全初始化之前就从构造函数中“逃逸”了。在这里,这是有意为之且无害的,因为派生类的[identify]方法不使用任何字段。在验证这一点之后,使用注解[@SuppressWarnings("this-escape")] (第 8 行)抑制该警告——仅针对这个构造函数。源代码启动器([java Main.java])不会启用这些警告:最好定期使用[javac -Xlint:all]来编译你的程序,本课程中所有程序我们都是这样做的。

类[UnknownUserException]如下:

1
2
3
4
5
6
7
8
public class UnknownUserException extends Exception {
    // 类的版本号(参见说明)
    private static final long serialVersionUID = 1L;

    public UnknownUserException(String message) {
        super(message);
    }
}
  • 第 1 行:它派生自类[Exception]。因此它是受检异常:编译器会验证任何可能抛出它的方法都使用[throws]子句声明了它,并且任何调用这种方法的代码要么捕获它,要么再次声明它。派生自[RuntimeException]的异常,例如[IllegalArgumentException],则不是受检异常;
  • 第 3 行:异常是“可序列化”的对象(可以转换为字节序列);在使用[-Xlint:all]选项时,编译器要求可序列化的类声明一个版本号[serialVersionUID]。我们只是使用值 1;
  • 第 5–7 行:它只有一个以错误消息为参数的构造函数。该消息被传递给父类,父类有相同的构造函数。

现在我们从类 [User] 派生子类[Administrator]:

public class Administrator extends User {
    // 构造函数
    public Administrator(String login, String password) throws UnknownUserException {
        super(login, password);
    }

    // 识别
    @Override
    protected String identify() {
        // LDAP 识别
        // ...
        return "admin";
    }
}
  • 第 3–5 行:构造函数只是把它收到的参数传递给其父类。它还声明了父类构造函数可能抛出的异常;
  • 第 8–13 行:[Administrator]类的 [identify] 方法。我们假定管理员通过 LDAP 目录进行识别。这个方法实现了其父类的抽象方法 [identify]。它保留了所重写方法的访问级别[protected] (重写的方法可以扩大访问权限,但不能缩小)。

类 [Observer] 和 [Unknown] 也派生自类[User]。它们与类[Administrator]的区别仅在于它们的方法[identify]。类 [Observer] 中的方法假定观察者通过数据库进行识别,并返回“observer”角色:

1
2
3
4
5
6
7
    // 识别
    @Override
    protected String identify() {
        // 通过数据库识别
        // ...
        return "observer";
    }

类[Unknown] 的方法返回引用[null] ,以表明用户未被识别:

1
2
3
4
5
6
7
    // 识别
    @Override
    protected String identify() {
        // 用户未知
        // ...
        return null;
    }

最终,[Administrator]、[Observer]、 和[Unknown] 对象都由同一个构造函数初始化——即父类[User]的构造函数。这个构造函数使用这些类提供的[identify]方法。[Main.java]的测试程序可能如下所示:

void main() {
    try {
        IO.println(new Observer("observer", "pwd1"));
        IO.println(new Administrator("admin", "pwd2"));
        IO.println(new Unknown("xx", "yy"));
    } catch (UnknownUserException e) {
        IO.println("Unknown user: " + e.getMessage());
    }
    // User u = new User("x", "y");   // 被拒绝:User 类是抽象的
}

请注意,在第 3 行和第 4 行,方法 [User.toString()]被方法 *[println]使用。在第 5 行,构造函数抛出了[UnknownUserException]异常,该异常在第 6 行被捕获:对象没有被创建,[println]也没有显示任何内容。这三个对象的创建被放在[try]块中,因为编译器要求捕获受检异常。第 9 行如果取消注释,会被编译器拒绝([User is abstract; cannot be instantiated]*):你不能创建抽象类的对象。

结果:

1
2
3
4
> java Main.java
User[observer,pwd1,observer]
User[admin,pwd2,admin]
Unknown user: [xx,yy]

抽象类与接口类似:两者都声明了其他类必须实现的方法。不过,抽象类可以拥有字段、构造函数以及其派生类共有的代码;反过来,一个类只能派生自一个抽象类,却可以实现多个接口。二者经常结合使用:接口定义契约,而实现它的抽象类则提取出多个实现共有的代码。本章的示例应用程序就将这样做。

4.8. 泛型类、接口和方法

4.8.1. 泛型类和方法

假设我们想编写一个类[IntPair] ,它存储两个整数并且可以交换它们:两个字段[int first] 和[int second],以及一个方法[swap()],它使用临时变量[int temp]交换它们的值。如果我们随后又想要一对字符串,再接着是一对人员,我们就要再写两个类,[StringPair] 和[PersonPair],除了类型之外与前一个完全相同:用[String] 或[Person] 代替[int]。

泛型类、接口和方法满足了对仅在某些数据的类型上有所不同的代码的需求。它们是随 Java 5(2004 年)引入的:在此之前使用的是类型[Object],它可以接受任何东西,代价是需要显式的类型转换,并且错误只能在运行时才被发现。请注意,Java 不支持按引用传递参数:方法无法交换调用方两个变量的值,但可以交换对象(例如一对值或数组)的两个元素。

程序[Classes18.java] 包含一个泛型类、一个泛型方法和第二个泛型类:

// 泛型类和泛型方法
void main() {
    // —— 泛型类 Pair<T>
    // Integer
    Pair<Integer> pi = new Pair<>(1, 2);
    pi.swap();
    IO.println("pi=" + pi);
    // String
    Pair<String> ps = new Pair<>("s1", "s2");
    ps.swap();
    IO.println("ps=" + ps);
    // Person
    Person p1 = new Person("jean", "clu", 20), p2 = new Person("pauline", "dard", 55);
    Pair<Person> pp = new Pair<>(p1, p2);
    pp.swap();
    IO.println("pp=" + pp);
    // 第一个元素的类型是 Person:无需转换
    Person first = pp.getFirst();
    IO.println("first element: " + first);

    // —— 泛型方法 Generic2.swap<T>
    Integer[] integers = { 1, 2, 3 };
    Generic2.<Integer>swap(integers, 0, 2);
    IO.println("integers=" + Arrays.toString(integers));
    // 编译器根据实参的类型推断出 T
    Person[] persons = { p1, p2 };
    Generic2.swap(persons, 0, 1);
    IO.println("persons=" + Arrays.toString(persons));

    // —— 有状态的泛型类:T 类型元素的栈
    MyStack<Person> stack = new MyStack<>();
    stack.push(p1);
    stack.push(p2);
    IO.println("The stack contains " + stack.size() + " persons");
    Person top = stack.pop();
    IO.println("Popped person: " + top + ", " + stack.size() + " left");
    // stack.push("x");   // 被拒绝:该栈只接受 Person 对象
}

// 泛型类:由两个 T 类型元素组成的对
class Pair<T> {
    private T first;
    private T second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    // 交换这两个元素
    public void swap() {
        T temp = first;
        first = second;
        second = temp;
    }

    @Override
    public String toString() {
        return "(" + first + "," + second + ")";
    }
}

// 带有泛型方法的非泛型类
class Generic2 {
    // 交换 T 类型元素数组中的第 i 个和第 j 个元素
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

// T 类型元素的栈
class MyStack<T> {
    // 栈中的元素
    private final List<T> elements = new ArrayList<>();

    // 元素个数
    public int size() {
        return elements.size();
    }

    // 在栈顶添加一个元素
    public void push(T element) {
        elements.add(element);
    }

    // 移除栈顶元素
    public T pop() {
        if (elements.isEmpty()) {
            throw new IllegalStateException("empty stack");
        }
        return elements.removeLast();
    }
}

// 一个人
record Person(String firstName, String lastName, int age) {
    @Override
    public String toString() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}
  • 第 41–69 行:类 [Pair] 由一个记为 *[T]的类型参数化,它写在类名后面的尖括号中。你可以随意命名它;按照惯例,它是一个大写字母([T] 表示类型,[E] 表示元素,[K] 和[V] 表示键和值)。这个类型[T],随后在类中像任何其他类型一样使用:用于两个字段、构造函数的参数、访问器的结果以及临时变量[temp]* (第 60 行)。类 [Pair] 被称为泛型类;
  • 第 5 行:使用由类型 T1、T2……参数化的泛型类时,必须指定这些类型。这里 [Pair<Integer>] 是一对[Integer]对象。泛型参数只能是引用类型:我们写[Pair<Integer>],而不是[Pair<int>]。整数 1 和 2 被自动转换为[Integer]对象(“自动装箱”)。在右侧,“菱形”运算符[new Pair<>(...)] 使编译器能够根据变量的类型推断出类型[Integer] 。第 9 行和第 14 行:类型[String] 和[Person]也是如此;
  • 第 18 行:[getFirst] 方法(在 [Pair<Person>] 上调用)返回[Person]类型的对象,无需转换;
  • 第 72–79 行:类[Generic2] 不是泛型的,但它的静态方法[swap] 是泛型的:类型为[<T>] 的参数声明在返回类型之前(第 74 行)。该方法交换类型为[T]的元素数组中第 i 个和第 j 个元素;
  • 第 23 行:调用方法 [swap] 时,在 *[T] 和 ***[<>] 之间指定了类型。实际上,编译器能够根据实参的类型推断出[T] 。因此,第 27 行的写法是合法的,实践中使用的也是这种写法;
  • 第 82–103 行:一个带有状态的泛型类:类型为[T]的元素栈。元素被压入栈顶并从栈顶弹出。元素存储在类型为[List<T>] 的泛型列表中(第 84 行),该列表本身由栈的[T]类型参数化。方法[removeLast] (Java 21)获取并返回列表的最后一个元素。空栈会抛出[IllegalStateException]异常,这是 Java 为对象不处于预期状态时所请求的操作而定义的异常;
  • 第 31 行:人员栈。编译器保证它只会包含人员:第 37 行的语句会被拒绝。方法[pop] 返回[Person]类型的对象,无需转换;
  • 第 106–111 行:Person 是一个记录,其方法[toString]已被重新定义。

结果:

1
2
3
4
5
6
7
8
9
> java Classes18.java
pi=(2,1)
ps=(s2,s1)
pp=([pauline, dard, 55],[jean, clu, 20])
first element: [pauline, dard, 55]
integers=[3, 2, 1]
persons=[[pauline, dard, 55], [jean, clu, 20]]
The stack contains 2 persons
Popped person: [pauline, dard, 55], 1 left

4.8.2. 泛型参数的边界

在[Pair<T>]类中,编译器对[T]类型一无所知:它只允许在类型为[T]的对象上调用[Object]类的方法。为了能够使用其他方法,我们使用关键字约束泛型参数[extends]:

约束
含义
[<T extends BaseClass>]
T 必须是指定的类或其派生类
[<T extends Interface>]
T 必须实现指定的接口(写作[extends],而不是[implements])
[<T extends BaseClass & I1 & I2>]
多重约束:至多一个类(列在最前面),后面跟接口
[<T extends Comparable<T>>]
使用 T 自身的边界:T 必须可与 T 比较

没有约束可以要求 T 是引用类型(它始终是引用类型)或者要求它具有无参构造函数:在泛型类中你不能写[new T()] (见下面的类型擦除)。程序[Classes19.java] 使用了一个约束:

// 泛型参数的边界
void main() {
    // —— T 始终是对象类型:int 被替换为 Integer
    Pair<Integer> pi = new Pair<>(1, 2);
    // Pair<int> pe = new Pair<>(1, 2);   // 错误:int 是基本类型
    IO.println("pi=" + pi);

    // —— 边界 T extends IValue
    // 对 RandomValue 类型的对象对进行排序
    for (int i = 0; i < 5; i++) {
        Pair<RandomValue> pair = new Pair<>(new RandomValue(), new RandomValue());
        IO.print("Before --> " + pair);
        Generic4.order(pair);
        IO.println("   After --> " + pair);
    }
    // 对 StringValue 类型的对象对进行排序
    Pair<StringValue> strings = new Pair<>(new StringValue("xxxxxxxxxxxxxx"), new StringValue("xx"));
    IO.println("Before --> " + strings);
    Generic4.order(strings);
    IO.println("After --> " + strings);
    // Generic4.order(pi);   // 错误:Integer 没有实现 IValue
}

// 由两个 T 类型元素组成的对
class Pair<T> {
    private T first;
    private T second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    public void swap() {
        T temp = first;
        first = second;
        second = temp;
    }

    @Override
    public String toString() {
        return "(" + first + "," + second + ")";
    }
}

// 类型 T 必须实现 IValue
class Generic4 {
    public static <T extends IValue> void order(Pair<T> pair) {
        // 如果第一个元素大于第二个,则交换这两个元素
        if (pair.getFirst().value() > pair.getSecond().value()) {
            pair.swap();
        }
    }
}

// 具有整数值的对象
interface IValue {
    int value();
}

// 具有随机值的对象
class RandomValue implements IValue {
    // 所有实例共享的随机数生成器
    // (用固定种子初始化,使结果可重现)
    private static final Random generator = new Random(2026);
    // 对象的值
    private final int value = generator.nextInt(100);

    @Override
    public int value() {
        return value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

// 值为字符串长度的对象
class StringValue implements IValue {
    private final String s;

    public StringValue(String s) {
        this.s = s;
    }

    @Override
    public int value() {
        return s.length();
    }

    @Override
    public String toString() {
        return s;
    }
}
  • 第 5 行:如果取消这一行的注释,编译器会报告错误,因为类型 *[int]* 是基本类型;
  • 第 55–62 行:泛型方法 [order] 要求类型[T] 实现接口[IValue] (第 65–67 行)。这个接口有一个名为[value] 的方法,在第 58 行使用,它返回类型为[T]的对象的值。如果没有这个边界,编译器会拒绝对[pair.getFirst().value()] 的调用:任何[T]类型都不一定有 [value] 方法。只有当第一个元素的值大于第二个元素的值时,这一对中的两个元素才会被交换:方法 [order] 按值把这两个元素按升序排序;
  • 第 70–86 行:类[RandomValue] 实现了接口[IValue]。实例的值是 0 到 99 之间的随机数(第 75 行),由所有实例共享的[Random]类中的随机数生成器提供(第 73 行)。该生成器用固定的“种子”初始化:因此它总是产生相同的数字序列,使结果可以重现。如果不需要可重现性,则使用由[new Random()]创建的生成器;出于安全目的,则改用类[SecureRandom];
  • 第 89–105 行:类[StringValue] 同样实现了接口[IValue]:实例的值是传给构造函数的字符串的长度;
  • 第 10–15 行:对类型为[RandomValue] 的对象对进行排序;
  • 第 17–20 行:对类型为[StringValue] 的对象对进行排序;
  • 第 21 行:如果取消这一行的注释,编译器会报告类型[Integer] 不满足边界。

结果:

1
2
3
4
5
6
7
8
9
> java Classes19.java
pi=(1,2)
Before --> (99,50)   After --> (50,99)
Before --> (97,30)   After --> (30,97)
Before --> (49,38)   After --> (38,49)
Before --> (73,36)   After --> (36,73)
Before --> (34,78)   After --> (34,78)
Before --> (xxxxxxxxxxxxxx,xx)
After --> (xx,xxxxxxxxxxxxxx)

下面是取消第 5 行和第 21 行的注释后运行程序所得到的错误:

> java Classes19.java
Classes19.java:5: error: unexpected type
    Pair<int> pe = new Pair<>(1, 2);   // error: int is a primitive type
         ^
  required: reference
  found:    int
Classes19.java:21: error: method order in class Classes19.Generic4 cannot be applied to given types;
    Generic4.order(pi);   // error: Integer does not implement IValue
            ^
  required: Classes19.Pair<T>
  found:    Classes19.Pair<Integer>
  reason: inference variable T has incompatible bounds
    equality constraints: Integer
    upper bounds: IValue
  where T is a type-variable:
    T extends IValue declared in method <T>order(Classes19.Pair<T>)
2 errors
error: compilation failed

第二条消息是涉及泛型的错误的典型代表:编译器试图推断类型[T];这一对的约束要求[T] = [Integer] (“相等约束”),而边界约束要求[T] 实现[IValue] (“上界”);这两个约束互不相容。

4.8.3. 泛型接口:Comparable<T> 和 Comparator<T>

为了说明泛型接口的概念,我们将按不同的标准对人员数组进行排序。对数组排序的方法是类[sort] 的静态方法[java.util.Arrays]。它是重载的;我们将使用其中两个变体:

  • [Arrays.sort(Object[] array)] 按照其元素的自然顺序对数组排序:这些元素必须实现[Comparable<T>]接口,该接口唯一的方法[int compareTo(T other)],把当前对象与[other]对象进行比较;
  • [Arrays.sort(T[] array, Comparator<? super T> comparator)] 按照由比较器对象定义的顺序对数组排序,该对象实现了[Comparator<T>]接口,其[int compare(T x, T y)]方法比较两个对象(类型[? super T] 将在下一段解释)。

方法[compareTo] 和[compare] 遵循相同的规则:如果 x > y 则返回正数,如果 x == y 则返回 0,如果 x < y 则返回负数。运算符 <、== 和 > 的含义由开发者来定义。例如,如果[p1] 和[p2] 是两个[Person]对象,当[p1] 的姓名按字母顺序排在[p2] 的姓名之后时,我们可以说 p1 > p2。这将得到按人员姓名的升序排序。如果我们想按年龄排序,则当[p1] 的年龄大于[p2]的年龄时,我们说 p1 > p2。要按降序排序,只需把结果的符号取反。

我们已经掌握了足够的知识来对人员表进行排序。程序[Classes20.java] 如下:

// 泛型接口 Comparable<T> 和 Comparator<T>:对人员数组排序
void main() {
    Person[] persons = {
        new Person("claude", "pollon", 25),
        new Person("valentine", "germain", 35),
        new Person("paul", "germain", 32),
    };
    // 显示
    display("Array to sort", persons);
    // 按人员的自然顺序(Comparable)排序:年龄
    Arrays.sort(persons);
    display("Array after sorting by age", persons);
    // 按姓氏和名字(Comparator)排序
    Arrays.sort(persons, new CompareNames());
    display("Array after sorting by last and first names", persons);
    // 用匿名类按年龄降序排序
    Arrays.sort(persons, new Comparator<Person>() {
        @Override
        public int compare(Person p1, Person p2) {
            return Integer.compare(p2.getAge(), p1.getAge());
        }
    });
    display("Array after sorting by descending age", persons);
}

// 显示人员数组
void display(String text, Person[] persons) {
    IO.println(text + "-".repeat(50 - text.length()));
    for (Person p : persons) {
        IO.println(p);
    }
}

// 一个可与另一个人比较的人
class Person implements Comparable<Person> {
    private final String firstName;
    private final String lastName;
    private final int age;

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // 人员的自然顺序:年龄顺序
    @Override
    public int compareTo(Person other) {
        return Integer.compare(age, other.age);
    }

    @Override
    public String toString() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}

// 比较两个人的姓氏和名字
class CompareNames implements Comparator<Person> {
    // 按法语规则比较字符串
    private final Collator collator = Collator.getInstance(Locale.FRENCH);

    @Override
    public int compare(Person p1, Person p2) {
        // 我们比较姓氏
        int i = collator.compare(p1.getLastName(), p2.getLastName());
        if (i != 0) {
            return i;
        }
        // 姓氏相同:我们比较名字
        return collator.compare(p1.getFirstName(), p2.getFirstName());
    }
}
  • 第 3–7 行:人员数组;
  • 第 35–68 行:类[Person] 实现了泛型接口[Comparable<Person>]:它的对象可以与其他人员比较。它的方法[compareTo] (第 59–62 行)定义了人员的自然顺序,这里是按年龄。静态方法[Integer.compare(a, b)] 根据[a] 小于、等于还是大于[b]而返回负数、零或正数:这正是方法[compareTo]所期望的;
  • 第 11 行:按自然顺序排序;
  • 第 14 行:按姓和名对人员数组排序。[sort]方法的第二个参数是[CompareNames]类的一个实例,该类实现了泛型接口[Comparator<Person>];
  • 第 71–85 行:类[CompareNames]。它的方法[compare] 实现了接口[int compare(T x, T y)] 中的方法[Comparator<T>],其中[T] = [Person]。字符串不使用其[compareTo]方法进行比较(该方法遵循字符编码的顺序:大写字母在小写字母之前,带重音的字母在“z”之后),而是使用[Collator]对象(第 73 行),它应用法语的排序规则;
  • 第 17–22 行:按年龄降序排序。这次比较器是匿名类的一个实例:表达式[new Comparator<Person>() { ... }] 声明了一个实现[Comparator<Person>]接口的无名类,并立即创建该类的实例。类体(第 18–21 行)提供了方法[compare]。匿名类避免了声明一个仅使用一次的类;
  • 第 28 行:[repeat]方法(Java 11)用于填充字符串:标题行用短横线填充到 50 个字符。

结果:

> java Classes20.java
Array to sort-------------------------------------
[claude, pollon, 25]
[valentine, germain, 35]
[paul, germain, 32]
Array after sorting by age------------------------
[claude, pollon, 25]
[paul, germain, 32]
[valentine, germain, 35]
Array after sorting by last and first names-------
[paul, germain, 32]
[valentine, germain, 35]
[claude, pollon, 25]
Array after sorting by descending age-------------
[valentine, germain, 35]
[paul, germain, 32]
[claude, pollon, 25]

我们现在已经遇到了三种声明在另一个类内部的类:静态嵌套类([static class])、内部类(没有 [static],它们与外围类的某个对象相关联)和匿名类。在第 7 章中,我们将看到,对于只有一个抽象方法的接口,例如[Comparator],我们可以使用比匿名类更简短的替代方案:lambda,即[Arrays.sort(persons, (p1, p2) -> Integer.compare(p2.getAge(), p1.getAge()));],或者方法引用,即[Arrays.sort(persons, Comparator.comparing(Person::getLastName));]。

4.8.4. 通配符和类型擦除

[List<Integer>] 不是[List<Number>],尽管[Integer] 派生自[Number]:如果是的话,我们就可以通过类型为[Double] 的变量向整数列表中添加一个[List<Number>]。因此,接受[List<Number>] 的方法会拒绝[List<Integer>]。为了编写接受相关类型元素列表的方法,Java 使用通配符:

类型
含义
用法
[List<? extends Number>]
由未知的、派生自[Number]的类型的元素组成的列表
可以从中读取[Number],但不能向其中添加元素
[List<? super Integer>]
由未知类型的元素组成的列表,[Integer] 派生自该类型([Integer]、[Number]、[Object])
可以向该列表添加 [Integer]
[List<?>]
由未知类型的元素组成的列表
可以读取[Object]

程序[Classes21.java] 说明了通配符以及 Java 泛型的一个特殊之处:类型擦除:

// 通配符、边界和类型擦除
void main() {
    List<Integer> integers = List.of(1, 2, 3);
    List<Double> reals = List.of(1.5, 2.25);
    // ? extends Number:元素类型派生自 Number 的列表
    IO.println("Sum of integers: " + sum(integers));
    IO.println("Sum of reals: " + sum(reals));
    // ? super Integer:可以接收 Integer 的列表
    List<Number> numbers = new ArrayList<>();
    addIntegers(numbers, 3);
    numbers.add(2.5);
    IO.println("numbers=" + numbers + ", sum=" + sum(numbers));
    // 递归边界:T 必须可与自身比较
    IO.println("max : " + max(List.of("paul", "jean", "valentine")) + ", " + max(integers));
    // 类型擦除:在运行时,列表就是列表
    List<String> l1 = new ArrayList<>();
    List<Integer> l2 = new ArrayList<>();
    IO.println("same class: " + (l1.getClass() == l2.getClass()) + " (" + l1.getClass().getName() + ")");
}

// 数字列表中元素之和
double sum(List<? extends Number> values) {
    double sum = 0;
    for (Number value : values) {
        sum += value.doubleValue();
    }
    // values.add(1);   // 被拒绝:元素的确切类型未知
    return sum;
}

// 将整数 1、2、……、n 添加到能够接收 Integer 的列表中
void addIntegers(List<? super Integer> list, int n) {
    for (int i = 1; i <= n; i++) {
        list.add(i);
    }
}

// 非空列表中最大的元素
<T extends Comparable<? super T>> T max(List<T> elements) {
    T max = elements.getFirst();
    for (T element : elements) {
        if (element.compareTo(max) > 0) {
            max = element;
        }
    }
    return max;
}
  • 第 22–29 行:[sum]方法接受由派生自[Number]的任意类型的元素组成的列表:[Integer]、[Double]、[BigDecimal]……它把元素视为[Number] ,并使用它们的[doubleValue]方法。Java 不支持泛型算术:你不能对类型为[a + b] 的两个对象写[T],因此需要使用[double]。向列表中添加元素(第 27 行)会被拒绝:编译器不知道它是[Integer] 列表还是[Double]列表;
  • 第 6–7 行:同一个方法把由[Integer] 组成的列表与由[Double]组成的列表连接起来。[List.of(...)] 创建一个只读列表;
  • 第 32–36 行:[addIntegers]方法接受任何能够容纳[Integer]条目的列表,这里是[List<Number>] (第 10 行)。我们遵循“生产者:[extends],消费者:[super]”的规则:读取其元素的列表使用[extends]来书写,而被填充的列表使用[super]来书写;
  • 第 39–47 行:泛型方法 *[max] 返回列表中最大的元素。[T extends Comparable<? super T>]边界要求元素之间可以相互比较;它既适用于字符串,也适用于整数(第 14 行)。[getFirst]*方法(Java 21)返回列表的第一个元素;
  • 第 16–18 行:在运行时,***[List<String>] 和 ***[List<Integer>] 是同一个类 *[ArrayList]* 的两个对象。编译器检查泛型类型,然后将其擦除:编译后的代码只认识[ArrayList]和[Object],并在必要之处插入转换。这种于 2004 年采用的“类型擦除”是为了确保泛型代码与已有代码保持兼容,它解释了若干限制:你不能写[new T()] 或[new T[10]],也不能测试[o instanceof List<String>],还不能把基本类型用作泛型参数。

结果:

1
2
3
4
5
6
> java Classes21.java
Sum of integers: 6.0
Sum of reals: 3.75
numbers=[1, 2, 3, 2.5], sum=8.5
max : valentine, 3
same class: true (java.util.ArrayList)

与 C# 等其他语言(接口中可以声明抽象静态成员来实现泛型计算)不同,Java 不允许要求像[T] 这样的类型具有静态方法:接口的静态方法通过接口名调用,并且不会被实现该接口的类继承。

4.9. 包

要在屏幕上输出一行,我们使用[IO.println(...)]语句。如果我们查看 JDK 文档中[IO]类的定义,会发现它属于[java.lang] 包。这意味着它的完整名称是[java.lang.IO] ,我们也可以写[java.lang.IO.println(...)]。[java.lang]包中的类([String]、[Object]、[Math]、[Integer]……)始终用它们的简单名称来引用。对于其他类,则使用放在文件开头的[import]子句:

  • [import java.util.List;] 从包[java.util]中导入类[List];
  • [import java.util.*;] 按需导入[java.util]包中所有的公共类;
  • [import module java.base;] (Java 25)导入由[java.base]模块导出的包中所有的公共类(见下文)。紧凑文件隐式地就是这样做的;
  • [import static java.lang.Math.sqrt;] 导入类的静态成员,之后无需指定类名即可使用它:[sqrt(2)]。

当编译器遇到类的短名称时,它会在当前包和已导入的类中查找。[import]子句不会给程序增加任何东西:它只是避免了写出完整名称。

创建类时,要把它放在某个包中。包的目的是避免类之间的名称冲突,例如在分发时。设想两家公司 E1 和 E2,分别分发打包在归档文件[e1.jar] 和[e2.jar] 中的类。假设客户 C 购买了这两套类,两家公司都在其中定义了名为[Person]的类。如果公司 E1 在名为[e1] 的包中创建其类,公司 E2 在名为[e2]的包中创建其类,那么这两个[Person] 类就将分别被命名为[e1.Person] 和 [e2.Person]。客户可以导入其中一个,并用完整名称引用另一个。包解决了这种歧义。按照惯例,包名使用小写,并以发布它们的组织的反向域名开头([com.mysql.cj.jdbc]、[org.hibernate]……);在我们的示例中,将使用简短的名称。

要把类放入某个包,需要在其文件顶部写上声明[package name;]。与其他语言不同,Java 要求包与目录一一对应:[e1]包的源文件存放在名为 [e1]的文件夹中,而[tax.dao]包的源文件则存放在从源目录根部开始、名为[tax/dao]的文件夹中。[Namespaces]文件夹演示了这些概念:

1
2
3
4
5
6
Namespaces/
  Main.java             the main program (unnamed package)
  e1/
    Person.java         the class e1.Person
  e2/
    Person.java         the class e2.Person

第一个类,[Person] [e1/Person.java]:

// 此文件中的类属于 e1 包
package e1;

public class Person {
    private final String firstName;
    private final String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return "e1.Person[" + firstName + ", " + lastName + "]";
    }
}

第二个:[e2/Person.java]:

// 此文件中的类属于 e2 包
package e2;

public class Person {
    private final String name;

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

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "e2.Person[" + name + "]";
    }
}

这两个类都是 public 的:没有关键字[public] 的类只能被其所在包中的类访问。主程序[Main.java] 如下:

// 从包中导入类
import e1.Person;
// 静态导入类的静态成员
import static java.lang.Math.sqrt;

void main() {
    // Person 指的是已导入的 e1.Person
    Person p1 = new Person("Jean", "Dupont");
    // 类的全名可以消除任何歧义
    e2.Person p2 = new e2.Person("Durand");
    IO.println(p1 + " " + p2);
    // 类的全名和所属包
    IO.println(Person.class.getName() + ", " + e2.Person.class.getName());
    IO.println("package of the Person class: " + Person.class.getPackageName());
    // 包含某个类的模块
    IO.println("e1.Person is in a named module: " + Person.class.getModule().isNamed());
    IO.println(String.class.getName() + " is in the module " + String.class.getModule().getName());
    // 由于自动导入了 java.base 模块,StringBuilder 是已知的
    StringBuilder sb = new StringBuilder("abc");
    IO.println(sb.append("def"));
    // 由于静态导入,sqrt 是已知的
    IO.println("sqrt(2)=" + sqrt(2));
}
  • 第 2 行:导入类[e1.Person];
  • 第 4 行:静态导入类[Math] 中的方法[sqrt] ;
  • 第 8 行:[Person] 指的是被导入的类[e1.Person];
  • 第 10 行:类[e2.Person] 的完整名称消除了任何歧义。Java 不支持类型别名:你不能给类起一个不同的名称;
  • 第 13–14 行:类描述中的方法[getName] 返回带有包名前缀的完整名称;[getPackageName] 返回包名;
  • 第 16–17 行:方法[getModule] 返回包含该类的模块(见下文);
  • 第 19–20 行:类[java.lang.StringBuilder] 无需导入即可识别;
  • 第 22 行:使用静态导入。

源代码启动器会自动在子文件夹中查找类:在[java Main.java]命令(在[Namespaces]文件夹中输入)下,会按需编译文件[e1/Person.java] 和 [e2/Person.java] 。结果:

1
2
3
4
5
6
7
8
> java Main.java
e1.Person[Jean, Dupont] e2.Person[Durand]
e1.Person, e2.Person
package of the Person class: e1
e1.Person is in a named module: false
java.lang.String is in the module java.base
abcdef
sqrt(2)=1.4142135623730951

如果我们把第 2 行的导入替换为两个按需导入[import e1.*;] 和[import e2.*;],名称[Person] 就会产生歧义,编译器会拒绝它:

1
2
3
4
5
6
> java Main.java
Main.java:9: error: reference to Person is ambiguous
    Person p1 = new Person("Jean", "Dupont");
    ^
  both class e2.Person in e2 and class e1.Person in e1 match
...

4.9.1. 模块

从 Java 9 开始,包本身被归入模块 (“Java 平台模块系统”,JPMS)。JDK 被划分为多个模块:[java.base] 包含核心包([java.lang]、[java.util]、[java.math]、[java.io]……),[java.sql] 提供数据库访问,[java.net.http] 是 HTTP 客户端,等等。模块在位于其源代码根目录的名为[module-info.java] 的文件中声明自己的名称、它所需要的模块([requires java.sql;])以及它向其他模块开放的包([exports tax.business;]):未导出的包从外部是不可见的,即使其中的类是公共的。没有声明模块的应用程序(例如我们的应用程序)中的类属于未命名模块 (结果的第 5 行),它可以访问所有模块。大多数应用程序都是这种情况,本课程中的所有应用程序也是如此:模块主要对库的作者和 JDK 自身的模块有意义。

4.10. 记录

许多类只用于承载数据:人员、成绩、税率档……对于这些类,我们总是编写相同的代码:私有的、[final]的字段,把参数复制到字段中的构造函数,访问器,显示字段的[toString] 方法,以及[equals] 和[hashCode] 方法。Java 16 引入了记录:编译器根据一行声明生成这些代码。我们在不可变对象一节中已经遇到过它们;程序[Classes22.java] 更全面地演示了它们:

// 记录(Java 16)
void main() {
    Person r1 = new Person("Jean", "Dupont", 30);
    Person r2 = new Person("Jean", "Dupont", 30);
    // 由编译器生成的 toString
    IO.println(r1);
    // 访问器与组件同名
    IO.println("first name=" + r1.firstName() + ", identity=" + r1.identity());
    // 按值相等:r1 和 r2 是两个不同但相等的对象
    IO.println("r1.equals(r2) : " + r1.equals(r2) + ", r1 == r2 : " + (r1 == r2));
    // 组件是只读的
    // r1.age = 31;   // 被拒绝:age 字段是 final
    // 用“wither”方法得到的修改后副本
    Person r3 = r1.withAge(31);
    IO.println(r3);
    IO.println("r1.equals(r3) : " + r1.equals(r3));
    // 用记录模式解构为变量(Java 21)
    if (r1 instanceof Person(String firstName, String lastName, int age)) {
        IO.println("first name=" + firstName + ", last name=" + lastName + ", age=" + age);
    }

    // 用类实现同样的功能
    PersonC c1 = new PersonC("Jean", "Dupont", 30);
    PersonC c2 = new PersonC("Jean", "Dupont", 30);
    IO.println(c1);
    IO.println("c1.equals(c2) : " + c1.equals(c2));

    // 实现同一个接口的两个记录
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    IO.println(e);
    IO.println(e.identity());
    // 相等性考虑类型:Person 不等于 Teacher
    Person pe = new Person("Lucile", "Dumas", 56);
    IO.println("pe.equals(e) : " + pe.equals(e));
    // 公共类型:HasIdentity 接口
    HasIdentity[] identities = { pe, e };
    for (HasIdentity i : identities) {
        IO.println(i.identity());
    }
}

// 由记录实现的接口
interface HasIdentity {
    String identity();
}

// 记录:firstName、lastName、age 是它的组件
record Person(String firstName, String lastName, int age) implements HasIdentity {
    // 可以添加方法
    @Override
    public String identity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // “wither”方法:其中一个组件发生变化的副本
    public Person withAge(int age) {
        return new Person(firstName, lastName, age);
    }
}

// 记录不能从另一个记录派生
record Teacher(String firstName, String lastName, int age, int section) implements HasIdentity {
    @Override
    public String identity() {
        return "Teacher[[" + firstName + ", " + lastName + ", " + age + "]," + section + "]";
    }
}

// 等价的类……或者差不多
final class PersonC {
    private final String firstName;
    private final String lastName;
    private final int age;

    public PersonC(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String firstName() {
        return firstName;
    }

    public String lastName() {
        return lastName;
    }

    public int age() {
        return age;
    }
}
  • 第 48–59 行:记录[Person]。声明[record Person(String firstName, String lastName, int age)] 会生成:
    • 三个私有的[final]字段——[firstName]、[lastName]和[age]——它们是记录的组件;
    • 一个三参数构造函数,称为规范构造函数;
    • 三个公共访问器:[firstName()]、[lastName()]和[age()] (第 8 行);
    • 显示类型名称及其组件的方法[toString] (第 6 行);
    • 方法[equals] 和[hashCode],它们比较组件的值而不是引用;
  • 第 51–53 行和第 56–58 行:记录与类一样,可以有额外的方法并实现接口(第 48 行);
  • 第 10 行:[r1] 和[r2] 是两个不同的对象([==] 的结果与[false]相同),但由于它们的组件值相同,它们按[equals] 是相等的。对于普通类,[equals] 比较的是引用(第 26 行);
  • 第 14 行:由于记录是不可变的,不能被修改(第 12 行):“wither”方法[withAge] 创建一个年龄已改变的[r1] 的副本;
  • 第 18–20 行:记录模式(Java 21):如果[r1] 是一个[Person],它的组件会被提取到变量[firstName]、[lastName]、和[age]中。这称为记录解构。在按模式过滤时我们还会再次遇到这些模式;
  • 第 62–67 行:记录隐式地是 final 的,并且隐式地派生自类[java.lang.Record];它不能派生自另一个类或记录,也不能被派生。为了使记录[Person] 和[Teacher] 拥有共同的类型,我们让它们实现同一个接口,这里是[HasIdentity] (第 43–45 行)。因此记录[Teacher] 包含了人员的各个组件;
  • 第 34 行:记录的相等性会考虑对象的实际类型:[Person] 永远不等于[Teacher],即使它们共有的组件相等;
  • 第 36–39 行:共同的接口使得这两个记录可以被多态地处理;
  • 第 70–92 行:一个类似于[Person] 记录的类……只不过字段、构造函数和访问器都必须手工编写,并且不提供按值相等和[toString] 。

结果:

> java Classes22.java
Person[firstName=Jean, lastName=Dupont, age=30]
first name=Jean, identity=[Jean, Dupont, 30]
r1.equals(r2) : true, r1 == r2 : false
Person[firstName=Jean, lastName=Dupont, age=31]
r1.equals(r3) : false
first name=Jean, last name=Dupont, age=30
Classes22$PersonC@206a70ef
c1.equals(c2) : false
Teacher[firstName=Lucile, lastName=Dumas, age=56, section=61]
Teacher[[Lucile, Dumas, 56],61]
pe.equals(e) : false
[Lucile, Dumas, 56]
Teacher[[Lucile, Dumas, 56],61]

请注意,类[toString] 的方法[PersonC] 与类[Object] 的方法相同(结果的第 8 行),并且两个[PersonC] 对象的相等性为 false(第 9 行)。

让我们总结一下类与记录的区别:

 
类
记录
[equals]的相等性
同一个对象(除非被重新定义)
组件值相同,类型相同
[toString]
类名和哈希码
记录名和组件
字段、构造函数、访问器
需要手工编写
由声明生成
状态
可修改或不可修改
不可变(字段为[final]),除组件外没有其他实例字段
修改后的副本
需要手工编写
需要手工编写(使用“wither”方法)
继承
可继承一个类,可实现多个接口
不能继承任何类,可实现多个接口;记录始终是 final 的

记录用于由其值定义的数据(从数据库中检索出的人员、通过网络交换的消息、税率档),而类用于具有标识和行为的对象(计算服务、连接、可变列表)。注意:记录只是“表面上”不可变:如果某个组件引用了可变对象(例如列表),该列表的内容仍然是可变的。在这种情况下,应使用不可变列表([List.copyOf])。

4.11. 记录的构造函数

记录的规范构造函数只是把其参数复制到字段中。不过,你可能想验证或规范化这些参数。Java 为此提供了紧凑构造函数,同时也允许添加其他构造函数。程序[Classes23.java] 对此进行了说明:

// 记录的构造函数:紧凑构造函数,其他构造函数
void main() {
    Person p = new Person("  Jean ", "Dupont", 30);
    IO.println(p.identity());
    // 记录是不可变的:growOlder 返回一个新的人
    Person p2 = p.growOlder();
    IO.println(p.identity() + " -> " + p2.identity());
    // 另一个构造函数
    Person unknown = new Person("Martin");
    IO.println(unknown.identity());
    // 紧凑构造函数中的检查
    try {
        new Person("Paul", " ", 20);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    try {
        new Person("Paul", "Martin", -4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    // 带方法和静态工厂的记录
    Point pt = new Point(3, 4);
    IO.println("pt=" + pt + ", distance to the origin: " + pt.distance() + ", origin=" + Point.origin());
}

record Person(String firstName, String lastName, int age) {
    // 紧凑构造函数:它检查并规范化参数,
    // 然后字段自动初始化
    Person {
        firstName = check(firstName, "first name");
        lastName = check(lastName, "last name");
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
    }

    // 任何其他构造函数都必须调用规范构造函数
    Person(String lastName) {
        this("?", lastName, 0);
    }

    // 返回新的人的方法
    public Person growOlder() {
        return new Person(firstName, lastName, age + 1);
    }

    public String identity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // 静态检查方法
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value.strip();
    }
}

record Point(double x, double y) {
    // 允许静态字段,不允许实例字段
    private static final Point ORIGIN = new Point(0, 0);

    public static Point origin() {
        return ORIGIN;
    }

    public double distance() {
        return Math.sqrt(x * x + y * y);
    }
}
  • 第 30–36 行:紧凑构造函数。它不带参数列表;其参数隐式地就是规范构造函数的参数([firstName]、[lastName]、[age])。它的代码首先执行;然后字段会自动用参数的值(这些值可能已被修改)进行初始化。这里,名和姓被验证并去除了首尾空格(第 31–32 行),负的年龄被拒绝(第 33–35 行)。在紧凑构造函数中,不能给字段赋值([this.firstName = ...] 会被拒绝):你要修改的是参数;
  • 第 39–41 行:记录可以有其他构造函数,但这些构造函数必须通过[this(...)]调用规范构造函数:因此任何[Person] 的创建都会经过紧凑构造函数的验证;
  • 第 44–46 行:记录是不可变的;让它“变老”意味着创建一个新实例;
  • 第 53–58 行:一个静态私有验证方法;
  • 第 61–72 行:记录可以有静态字段(第 63 行)和静态方法(第 65–67 行),例如静态工厂方法[origin],但除组件之外不能有其他实例字段。

结果:

1
2
3
4
5
6
7
> java Classes23.java
[Jean, Dupont, 30]
[Jean, Dupont, 30] -> [Jean, Dupont, 31]
[?, Martin, 0]
last name ( ) invalid
age (-4) invalid
pt=Point[x=3.0, y=4.0], distance to the origin: 5.0, origin=Point[x=0.0, y=0.0]

两侧带有空格提供的名字(第 3 行)在存储时去掉了这些空格(结果的第 2 行)。紧凑构造函数是确保记录始终有效的惯用方式:不使用它就无法创建[Person] 。

4.12. 没有扩展方法:静态工具方法

如何向无法修改的类(例如 JDK 中的[String]类)添加方法?某些语言(如 C# 或 Kotlin)提供“扩展方法”:这是一些像被扩展类型的实例方法那样使用的静态方法。Java 没有它们。我们改为编写静态方法,把它们归入一个工具类,并通过类名调用,把对象作为参数传入。JDK 中到处都是这样的类:[Arrays]、[Collections]、[Objects]、[Math]……程序[Classes24.java] 对此进行了说明:

// Java 中没有扩展方法:使用静态工具方法
import static java.lang.Character.toUpperCase;

void main() {
    Person p = new Person("jean", "dupont", 30);
    // 工具方法用其所属类的名称调用
    IO.println(Tools.initials(p));
    IO.println(Tools.firstUpper("jean"));
    IO.println(Tools.fullName(p) + " is an adult: " + Tools.isAdult(p));
    IO.println("\"it is sunny\" has " + Tools.nbWords("it is sunny") + " words");
    // 记录自身的静态方法
    Person unknown = Person.unknown();
    IO.println(Tools.fullName(unknown) + " is an adult: " + Tools.isAdult(unknown));
}

// 一个人
record Person(String firstName, String lastName, int age) {
    // 静态工厂:一个未知的人
    static Person unknown() {
        return new Person("?", "?", 0);
    }
}

// 工具类:final,私有构造函数,静态方法
final class Tools {
    private Tools() {
    }

    static String initials(Person p) {
        return toUpperCase(p.firstName().charAt(0)) + "." + toUpperCase(p.lastName().charAt(0)) + ".";
    }

    static String firstUpper(String s) {
        return s.isEmpty() ? s : toUpperCase(s.charAt(0)) + s.substring(1);
    }

    static boolean isAdult(Person p) {
        return p.age() >= 18;
    }

    static String fullName(Person p) {
        return firstUpper(p.firstName()) + " " + p.lastName().toUpperCase();
    }

    static int nbWords(String s) {
        return s.isBlank() ? 0 : s.strip().split("\\s+").length;
    }
}
  • 第 25–48 行:工具类[Tools]。它是 final 的,其唯一的构造函数是私有的(第 26–27 行):它不能被派生也不能被实例化。它的所有方法都是静态的;
  • 第 29–31 行:方法[initials] 以人员作为参数。与写在另一个文件中的工具类一样,它只使用 [Person] 记录的公共成员——这里是它的访问器(不过在紧凑文件中,它可以访问私有字段);[charAt(0)] 返回字符串的第一个字符;
  • 第 2 行:对方法[Character.toUpperCase](它把字符转换为大写)的静态导入,使得可以不带类名调用它(第 30 行和第 34 行);
  • 第 45–47 行:方法[nbWords] 使用方法[split]拆分字符串,该方法的参数是正则表达式:["\\s+"] 匹配由一个或多个空白字符组成的序列;
  • 第 7–10 行:工具方法通过类名调用:[Tools.initials(p)],而不是 [p.initials()];
  • 第 19–21 行:当类型可以被修改时,它的方法自然就放在其中:静态工厂方法[unknown] 是记录[Person] 的方法(第 12 行)。

结果:

1
2
3
4
5
6
> java Classes24.java
J.D.
Jean
Jean DUPONT is an adult: true
"it is sunny" has 3 words
? ? is an adult: false

使用静态导入(如果该类位于名为[import static tools.Tools.*;] 的包中,则为[tools]),就可以不带类名而写[initials(p)] 。工具方法要可用,其所在的类必须可访问,并且如果它在另一个包中,还必须被导入。

4.13. 对象的模式匹配

[switch]语句和模式匹配并不限于简单的值(数字、字符串);它们也适用于对象。你可以测试对象的类型、解构记录、添加条件,并获取转换为正确类型的对象——全部在一个表达式中完成。程序[Classes25.java] 使用了一个密封接口和实现它的三个记录:

// 对象的模式匹配
void main() {
    Object[] objects = {
        new Individual("Jean", "Dupont", 30),
        new Individual("Lise", "Morel", 12),
        new Teacher("Lucile", "Dumas", 56, 61),
        new Teacher("Marc", "Petit", 44, 27),
        new Student("Paul", "Martin", 19, "computer science"),
        "a string",
        42,
        null,
    };

    // 1 - 类型模式:instanceof Type variable(Java 16)
    for (Object o : objects) {
        if (o instanceof Person p) {
            // 这里 p 是一个 Person
            IO.println(p.firstName() + " is of type " + p.getClass().getSimpleName());
        }
    }

    // 2 - 后面带条件的类型模式
    for (Object o : objects) {
        if (o instanceof Person p && p.age() >= 18) {
            IO.println(p.firstName() + " is an adult");
        }
    }

    // 3 - 按对象类型的 switch,带守卫和记录模式(Java 21)
    for (Object o : objects) {
        IO.println(describe(o));
    }

    // 4 - 对密封接口的穷尽 switch
    for (Object o : objects) {
        if (o instanceof Person p) {
            IO.println(p.firstName() + " : " + category(p));
        }
    }
}

String describe(Object o) {
    return switch (o) {
        case Teacher e when e.section() == 27 -> e.firstName() + " teaches computer science";
        case Teacher e -> e.firstName() + " teaches in section " + e.section();
        case Student(var firstName, _, _, var major) -> firstName + " studies " + major;
        case Person p when p.age() < 18 -> p.firstName() + " is a minor";
        case Person p -> p.firstName() + " is " + p.age() + " years old";
        case String s -> "a string of " + s.length() + " characters";
        case Integer n when n > 0 -> "the positive integer " + n;
        case null -> "the null reference";
        default -> "an unknown object";
    };
}

// 没有 default:编译器知道这三种情况涵盖了所有人员
String category(Person p) {
    return switch (p) {
        case Individual _ -> "individual";
        case Teacher _ -> "teacher";
        case Student _ -> "student";
    };
}

// 一个密封接口和实现它的三个记录
sealed interface Person permits Individual, Teacher, Student {
    String firstName();
    String lastName();
    int age();
}

record Individual(String firstName, String lastName, int age) implements Person {
}

record Teacher(String firstName, String lastName, int age, int section) implements Person {
}

record Student(String firstName, String lastName, int age, String major) implements Person {
}
  • 第 66–79 行:密封接口[Person],由三个记录实现:[Individual]、[Teacher] 和 [Student]。该接口声明了方法[firstName]、[lastName]和[age]:记录通过其访问器自动实现这些方法,因为它们有同名的组件。由于记录是 final 的,它无需进一步说明就可以实现密封接口;
  • 第 3–12 行:由各种类型的对象组成的数组,其中包括一个整数(自动转换为 *[Integer])和引用 *[null];
  • 第 16 行:类型模式[o instanceof Person p] (Java 16)在[o] 引用类型为[Person]的对象时为真;此时,类型为[p]的变量[Person]引用这个对象。这避免了 Java 16 之前使用的那套做法:先用[instanceof]测试类型,然后用[(Person) o]进行转换。当[o] 等于[null]时,该模式为假;
  • 第 24 行:模式变量[p] 可以在条件的其余部分中使用,即在[&&]之后:Java 没有属性模式;字段的值要通过条件来测试;
  • 第 42–54 行:对象上的[switch] 表达式(Java 21)按顺序尝试各个模式,并返回与第一个匹配的模式关联的值:
    • 第 44 行:27 组的教师。子句[when] 为类型模式添加了一个条件,称为守卫;
    • 第 45 行:任何其他教师。顺序很重要:如果把这个模式放在前一个之前,就会使前一个无法到达,编译器会将此报告为错误;
    • 第 46 行:记录模式:它按声明的顺序提取记录[Student] 的各个组件;[var] 让编译器推断它们的类型,而字符[_] (Java 22)则忽略某个组件;
    • 第 47–48 行:一个未成年人,然后是任何其他人员;
    • 第 50 行:一个正整数;
    • 第 51 行:[null]分支。如果没有它,对空引用执行[switch] 会抛出[NullPointerException]异常;
    • 第 52 行:[default]分支处理其他所有情况。如果没有它,编译器会报告表达式[switch]没有覆盖所有情况:对象上的[switch] 必须是穷尽的;
  • 第 57–63 行:对[switch]的[Person]进行匹配,没有[default]。然而它是穷尽的:由于接口是密封的,编译器知道一个人要么是[Individual]、[Teacher] 要么是 [Student]。模式[Individual _] 测试类型而不声明变量。

结果:

> java Classes25.java
Jean is of type Individual
Lise is of type Individual
Lucile is of type Teacher
Marc is of type Teacher
Paul is of type Student
Jean is an adult
Lucile is an adult
Marc is an adult
Paul is an adult
Jean is 30 years old
Lise is a minor
Lucile teaches in section 61
Marc teaches computer science
Paul studies computer science
a string of 8 characters
the positive integer 42
the null reference
Jean : individual
Lise : individual
Lucile : teacher
Marc : teacher
Paul : student

如果从方法[Student]中删除分支[category],编译器会报告错误:

1
2
3
4
5
6
> java Classes25.java
Classes25.java:58: error: the switch expression does not cover all possible input values
    return switch (p) {
           ^
1 error
error: compilation failed

这正是把密封类型与模式过滤结合起来的巨大优势:如果向层次结构中添加第四个记录,编译器会指出所有需要补全的[switch]。还要注意,类型模式对应的是实现该接口的类型:类型模式循环(第 15–20 行)选出了这三种类型的人员。模式过滤是级联[if (o instanceof ...)]语句的一个有用替代方案;不过,它不应取代多态:当行为取决于对象的类型并且类层次结构定义明确时,在每个类中重新定义的方法通常仍然是面向对象的解决方案。基于模式的过滤适用于数据层次结构(记录),我们希望针对这些数据编写外部的处理逻辑。

4.14. 处理 null 值

任何引用类型的变量都可以取值[null],使用空引用会引发[NullPointerException]异常,这是 Java 中最常见的运行时错误。与 C# 或 Kotlin 等其他语言不同,Java 编译器不区分可以为[null] 的类型和不可以为 null 的类型。不过,JDK 和各种库提供了若干工具来降低这种风险:

  • [Optional<T>]类(Java 8),用作可能不返回任何内容的方法的返回类型;
  • [Objects]类的方法:[requireNonNull] 用于在方法或构造函数的入口处拒绝[null] ,而[requireNonNullElse] 用于提供默认值;
  • 记录意图并由某些分析工具验证的注解。最新的一批注解由一组厂商(Google、JetBrains、Spring……)提出,来自 JSpecify 库:[@Nullable] 用于可以为[null]的类型,而[@NullMarked] 用于类或包,表示其他类型不能为 null。我们将要使用的 Spring Framework 7 就采用了它们。它们需要一个库,因此本章中我们不会使用它们。

程序[Classes26.java] 演示了前两种工具:

// 处理 null 值:Optional、Objects.requireNonNull……
void main() {
    Person jean = new Person("Jean", "Dupont");
    jean.setMiddleName("Marie");
    Person[] persons = { jean, new Person("Paul", "Martin") };
    for (Person p : persons) {
        // 引用为 null 时的默认值
        String middle = Objects.requireNonNullElse(p.getMiddleName(), "(none)");
        // 显式测试
        String length = p.getMiddleName() == null ? "null" : String.valueOf(p.getMiddleName().length());
        IO.println(p.getFirstName() + " : middle name=" + middle + ", length=" + length);
    }

    // 可能一无所获的方法:返回 Optional<Person>
    Optional<Person> found = find(persons, "Durand");
    IO.println("Durand found: " + found.isPresent());
    IO.println(found.map(Person::getFirstName).orElse("Durand: person not found"));
    // 使用值之前先测试它是否存在
    found = find(persons, "Martin");
    if (found.isPresent()) {
        IO.println("Martin : " + found.get().getFirstName());
    }
    // ifPresent:仅当存在值时才执行该操作
    find(persons, "Dupont").ifPresent(p -> p.setMiddleName("Louise"));
    find(persons, "Durand").ifPresent(p -> p.setMiddleName("Louise"));
    IO.println(jean.getMiddleName());
    // orElseThrow:我们断言值存在,否则抛出异常
    Person martin = find(persons, "Martin").orElseThrow();
    IO.println(martin.getFirstName());

    // Objects.requireNonNull:必需参数
    try {
        new Person(null, "Morel");
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
    // NullPointerException 异常及其详细消息(Java 14)
    try {
        Person lise = new Person("Lise", "Morel");
        IO.println(lise.getMiddleName().length());
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
}

// 按姓氏搜索人员
Optional<Person> find(Person[] persons, String lastName) {
    for (Person p : persons) {
        if (p.getLastName().equals(lastName)) {
            return Optional.of(p);
        }
    }
    return Optional.empty();
}

class Person {
    // 必填字段:它们绝不能为 null
    private final String firstName;
    private final String lastName;
    // 可选字段:null 表示“没有中间名”
    private String middleName;

    public Person(String firstName, String lastName) {
        this.firstName = Objects.requireNonNull(firstName, "the first name is mandatory");
        this.lastName = Objects.requireNonNull(lastName, "the last name is mandatory");
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public String getMiddleName() {
        return middleName;
    }

    public void setMiddleName(String middleName) {
        this.middleName = middleName;
    }
}
  • 第 56–83 行:[Person]类有两个由构造函数初始化的必需字段,以及一个可选字段[middleName]:[null] 表示“没有中间名”。构造函数拒绝值为[null] 的名或姓,为此使用 [Objects.requireNonNull] (第 64–65 行):错误在对象创建时就被检测到,而不是等到很久以后使用该字段时;
  • 第 8 行:[Objects.requireNonNullElse(value, defaultValue)] (Java 9)在 [value] 不等于[null]时返回它;否则返回 [defaultValue];
  • 第 10 行:显式检查往往是最简单的做法;
  • 第 47–54 行:方法[find] 返回被查找的人员,包装在[Optional]对象中,或者返回一个空的[Optional]:它的返回类型[Optional<Person>]提醒调用方结果可能缺失,并要求调用方处理这种情况才能取出人员。[Optional.of(p)] 创建一个包含[Optional] 的[p],[Optional.empty()],则创建一个空的[Optional];
  • 第 16 行:[isPresent] 表示[Optional] 是否包含值;
  • 第 17 行:[map(Person::getFirstName)] 把存在的人员转换为其名;[orElse(value)] 返回存在的值,如果没有则返回指定的值。写法[Person::getFirstName] 是一个方法引用,我们将在第 7 章中研究;在这里它指的是“该人员的[getFirstName] 方法”;
  • 第 20–22 行:[get] 返回存在的值;只有在确认其存在之后才会调用它;
  • 第 24–25 行:[ifPresent] 仅在存在值时才执行指定的操作。该操作是一个lambda (第 7 章):[p -> p.setMiddleName("Louise")] 读作“对于人员 p,设置其中间名”。Dupont 存在并被赋予了新的中间名;Durand 不存在,该语句什么也不做;
  • 第 28 行:[orElseThrow] 在值存在时返回该值,如果[NoSuchElementException]为空,则抛出[Optional] 异常。当你确定值存在时使用它;
  • 第 32–36 行:没有名的人员会被构造函数拒绝;
  • 第 38–43 行:使用空引用会抛出[NullPointerException]异常。自 Java 14 起,它的消息会明确指出为 null 的表达式。

结果:

> java Classes26.java
Jean : middle name=Marie, length=5
Paul : middle name=(none), length=null
Durand found: false
Durand: person not found
Martin : Paul
Louise
Paul
Error: the first name is mandatory
Error: Cannot invoke "String.length()" because the return value of "Classes26$Person.getMiddleName()" is null

[Optional] 用于方法的返回值;它不用于字段或参数。在本课程中,我们会注明某个值是否可选,使用[Objects.requireNonNull]验证必需的参数,并且相比逐步填充的对象,我们更倾向于始终完整的对象(用其所有必需的值来构造)。

4.15. 示例应用程序 - V2

我们将回到上一章(版本 1)中已经讨论过的税款计算,现在用类和接口来实现它。让我们回顾一下问题。我们的目标是编写一个计算纳税人税款的程序。我们考虑一种简化的情形:纳税人只需申报其工资(采用 2004 年针对 2003 年收入的税率表,原样使用:这是一道练习):

  • 我们计算雇员的份数:未婚时 份数 = nbChildren / 2 + 1,已婚时为 nbChildren / 2 + 2,其中 nbChildren 是其子女的数量;
  • 如果他至少有三个孩子,则额外获得半份;
  • 他的应税收入 R 按 R = 0.72 × S 计算,其中 S 是他的年薪;
  • 他的家庭商数按 QF = R / 份数 计算;
  • 他的税款 I 按下表计算:
限额
coeffR
coeffN
4962
0
0
8382
0.068
291.09
14,753
0.191
1,322.92
23,888
0.283
2,668.39
38,868
0.374
4,846.98
47,932
0.426
6,883.66
0
0.481
9,505.54

每一行有三个字段。要计算税款 I,找到第一个满足 QF ≤ 限额的行。例如,如果 QF = 5,000,则会找到行 (8,382; 0.068; 291.09)。于是税款 I 等于 0.068 × R - 291.09 × 份数。如果 QF 使得条件 QF ≤ 限额始终不满足,则使用最后一行的系数,得到税款 I = 0.481 × R - 9,505.54 × 份数。

该应用程序生成文件[TaxV2]。计算类被组织在名为[tax]的包中:

1
2
3
4
5
6
7
TaxV2/
  Main.java                 the program that dialogues with the user
  tax/
    TaxBracket.java         a bracket of the tax scale
    ITax.java               the tax calculation interface
    AbstractTax.java        an abstract class implementing ITax
    HardwiredTax.java       a derived class, with hard-coded data

首先,我们定义一个能够封装上述数组中一行的类型[TaxBracket.java]:

1
2
3
4
5
6
7
package tax;

import java.math.BigDecimal;

// 税率表中的一档
public record TaxBracket(BigDecimal limit, BigDecimal coeffR, BigDecimal coeffN) {
}

我们使用记录:

  • 因为税率档是没有标识的小型数据,仅由其值定义,并且一旦创建就没有理由再修改:记录是不可变的;
  • 因为编译器仅根据一行代码就生成构造函数、访问器、[toString],以及相等运算符。

组件的类型是[BigDecimal] (包[java.math],因此第 3 行有 import)。类型[float] 和[double] 以二进制表示数字:像 0.068 这样的十进制数在其中没有精确的表示,计算会累积微小的舍入误差。[BigDecimal]类精确地表示十进制数:这是用于金额的类型。它的缺点是没有运算符:我们写[a.add(b)]、[a.multiply(b)]、[a.compareTo(b)]。

接下来,我们定义一个能够计算税款的接口[ITax] [ITax.java]:

1
2
3
4
5
6
package tax;

public interface ITax {
    // 纳税人的税款计算
    int calculate(boolean married, int nbChildren, int salary);
}
  • 第 5 行:根据三项数据计算税款的方法:纳税人的婚姻状况、子女数量和年薪。它把税款向下取整到整欧元。

接下来,我们定义一个实现该接口的抽象类[AbstractTax.java]:

package tax;

import java.math.BigDecimal;
import java.math.MathContext;
import java.util.List;

public abstract class AbstractTax implements ITax {
    // 计算所需的税率档来自外部来源
    // 只有派生类知道
    protected abstract List<TaxBracket> getTaxBrackets();

    // 税款计算
    @Override
    public int calculate(boolean married, int nbChildren, int salary) {
        // 计算份额数
        BigDecimal shares = BigDecimal.valueOf(nbChildren).divide(BigDecimal.TWO)
                .add(BigDecimal.valueOf(married ? 2 : 1));
        if (nbChildren >= 3) {
            shares = shares.add(new BigDecimal("0.5"));
        }
        // 计算应税收入和家庭商数
        BigDecimal income = new BigDecimal("0.72").multiply(BigDecimal.valueOf(salary));
        BigDecimal quotient = income.divide(shares, MathContext.DECIMAL128);
        // 查找税率档:如果没有合适的上限,则使用最后一档
        List<TaxBracket> brackets = getTaxBrackets();
        TaxBracket bracket = brackets.getLast();
        for (int i = 0; i < brackets.size() - 1; i++) {
            if (quotient.compareTo(brackets.get(i).limit()) <= 0) {
                bracket = brackets.get(i);
                break;
            }
        }
        // 税款计算
        return income.multiply(bracket.coeffR()).subtract(shares.multiply(bracket.coeffN())).intValue();
    }
}
  • 第 1 行:该类属于[tax]包;因此它的文件位于[tax]文件夹中;
  • 第 7 行:类[AbstractTax] 实现了接口[ITax];
  • 第 10 行:税率表数据,由一个受保护的抽象方法提供。[AbstractTax]类不知道这些数据来自何处(写在代码中、从文件读取、来自数据库等)。它把这一点留给派生类。这就是它被声明为抽象的原因,这样就阻止了它被实例化。该抽象方法要求派生类提供各个税率档;编译器会验证这一点;
  • 第 13–35 行:接口[calculate]的[ITax]方法的实现。派生类无需重写这个方法。因此[AbstractTax]类充当派生类的公共代码提取类:它包含它们所共有的内容;
  • 第 16–17 行:份数。[BigDecimal.valueOf(n)] 把整数转换为[BigDecimal];除以[BigDecimal.TWO] 是精确的(3 / 2 = 1.5),这不同于[nbChildren / 2] 的整数除法(3 / 2 = 1)。表达式[married ? 2 : 1] 对已婚纳税人等于 2,否则等于 1;
  • 第 18–20 行:额外的半份。[BigDecimal] 是不可变的:[add] 返回一个新对象,必须把它赋给变量;
  • 第 22–23 行:应税收入和家庭商数。十进制常量由字符串创建([new BigDecimal("0.72")])以确保它们是精确的。对[BigDecimal] 做除法可能产生无限位小数(1 / 3):我们指定所需的精度,这里是[MathContext.DECIMAL128] (34 位有效数字);
  • 第 25–32 行:查找税率档。默认是最后一个税率档([brackets.getLast()],第 26 行)。循环遍历除最后一个以外的所有税率档,并在第一个限额大于或等于家庭商数的税率档处停止([break]),这由[compareTo(...) <= 0]来测试;
  • 第 34 行:税款计算。方法[intValue] 把结果截断为其整数部分。

实现[ITax]接口的类可以通过从[AbstractTax]类派生来创建。我们现在用[HardwiredTax.java]来做这件事:

package tax;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

public class HardwiredTax extends AbstractTax {
    // 税款计算数据(2003 年收入的 2004 年税率表),“硬编码”
    private static final double[] LIMITS = { 4962, 8382, 14753, 23888, 38868, 47932, 0 };
    private static final double[] COEFF_R = { 0, 0.068, 0.191, 0.283, 0.374, 0.426, 0.481 };
    private static final double[] COEFF_N = { 0, 291.09, 1322.92, 2668.39, 4846.98, 6883.66, 9505.54 };

    // 税率档
    private final List<TaxBracket> taxBrackets;

    // 构造函数
    public HardwiredTax() {
        // 创建并填充税率档列表
        List<TaxBracket> brackets = new ArrayList<>();
        for (int i = 0; i < LIMITS.length; i++) {
            brackets.add(new TaxBracket(BigDecimal.valueOf(LIMITS[i]),
                    BigDecimal.valueOf(COEFF_R[i]), BigDecimal.valueOf(COEFF_N[i])));
        }
        // 存储的列表不可修改
        taxBrackets = List.copyOf(brackets);
    }

    // 实现父类的抽象方法
    @Override
    protected List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }
}
  • 第 9–11 行:类[HardwiredTax] 把计算税款所需的数据硬编码在其中。这些是类字段([static])[final]:它们由所有实例共享,并且不能被其他数组替换。按照惯例,常量([static final])的名称使用大写;
  • 第 17–26 行:构造函数使用这些数据构建税率档列表。[BigDecimal.valueOf(double)] (第 21–22 行)通过最短的十进制表示把[double] 转换为一个 [BigDecimal] :[BigDecimal.valueOf(0.068)] 恰好是 0.068。不要使用构造函数[new BigDecimal(0.068)],它会重现近似的二进制值的所有小数位(0.068000000000000004884981308350688…);
  • 第 25 行:[List.copyOf] 返回列表的只读副本:没有任何类能够修改税率表;
  • 第 29–32 行:实现了父类的抽象方法:它返回税率档列表。

下一章将添加其他派生自[AbstractTax]的类,它们将从文本文件或 JSON 中读取税率档:它们只需提供[getTaxBrackets]方法。

测试程序可以是下面的[Main.java]:

// 交互式税款计算程序
// 用户在键盘上输入三项数据:married nbChildren salary
// 程序随后显示应缴税款
import tax.HardwiredTax;
import tax.ITax;

static final String SYNTAX = """
        syntax: Married NbChildren Salary
        Married: y for married, n for not married
        NbChildren: number of children
        Salary: annual salary in euros""";

void main() {
    // 创建 ITax 对象
    ITax tax = new HardwiredTax();

    // 输入循环
    while (true) {
        // 我们询问税款计算的参数
        String parameters = IO.readln("Tax calculation parameters in the format: "
                + "Married (y/n) NbChildren Salary, or nothing to stop: ");
        // 标准输入结束或空行:我们停止
        if (parameters == null || parameters.isBlank()) {
            break;
        }
        // 检查所输入行的字段数
        String[] fields = parameters.strip().split("\\s+");
        if (fields.length != 3) {
            IO.println(SYNTAX);
            continue;
        }
        // 检查参数的有效性
        // married
        String married = fields[0].toLowerCase();
        if (!married.equals("y") && !married.equals("n")) {
            IO.println(SYNTAX + "\nIncorrect married argument: type y or n");
            continue;
        }
        // nbChildren
        int nbChildren = positiveInteger(fields[1]);
        if (nbChildren < 0) {
            IO.println(SYNTAX + "\nIncorrect NbChildren argument: type a positive or zero integer");
            continue;
        }
        // salary
        int salary = positiveInteger(fields[2]);
        if (salary < 0) {
            IO.println(SYNTAX + "\nIncorrect salary argument: type a positive or zero integer");
            continue;
        }
        // 参数正确:我们计算税款
        IO.println("Tax=" + tax.calculate(married.equals("y"), nbChildren, salary) + " euros");
    }
}

// 返回字符串所表示的正整数或零,如果字符串不表示这样的数则返回 -1
int positiveInteger(String input) {
    try {
        int value = Integer.parseInt(input);
        return value >= 0 ? value : -1;
    } catch (NumberFormatException ex) {
        return -1;
    }
}

上面的程序允许用户反复进行税款计算模拟。

  • 第 4–5 行:主程序位于未命名包中;它从[tax]包中导入它所需要的两个类型。这些类型必须是 public 的;
  • 第 7–11 行:帮助消息是隐式类的一个常量,写成用三个引号界定的文本块 (Java 15):字符串可以跨越多行,并且各行共同的缩进会被去除。由于结束引号放在最后一行的末尾,因此该字符串不以换行符结尾;
  • 第 15 行:创建一个实现[tax]接口的[ITax]对象。这个对象是通过实例化类型[HardwiredTax]得到的,该类型实现了接口[ITax]。请注意,变量[tax]的类型并未被指定为[HardwiredTax] ,而是[ITax]。这样写,我们表明自己只关心[calculate]对象的[tax]方法,而不关心其余部分。要使用文件中的数据,只需修改这一行;
  • 第 18–53 行:税款计算模拟的循环;
  • 第 20–21 行:[calculate]方法所需的三个参数通过键盘在一行中输入。[IO.readln(message)] 显示消息然后读取一行;如果标准输入已关闭,它返回[null] :此时第 23 行的检查会终止程序,就像输入空行一样;
  • 第 27 行:[split]方法把去掉首尾空格的行拆分为由一个或多个空格字符分隔的单词(正则表达式["\\s+"]);
  • 第 40 行和第 46 行:方法[positiveInteger] (第 57–64 行)验证最后两个字段是正整数或零。如果字符串不表示整数,[Integer.parseInt] 会抛出[NumberFormatException]异常:该方法捕获它并返回 -1,表示出错;
  • 第 52 行:调用实现[calculate]接口的[tax]对象的[ITax]方法。

下面是从[TaxV2]文件夹启动的程序执行示例:

> java Main.java
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d f
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -1 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

税款计算正确:一位已婚、有两个孩子、年薪 60,000 欧元的纳税人为 4,282 欧元(第 26 行),有三个孩子时为 2,959 欧元(第 28 行)。一位没有孩子的未婚纳税人在同样的工资下要缴纳 11,519 欧元(第 30 行)。

与版本 1 相比,计算现在被封装在接口背后的类中:对话程序只认识[ITax]接口。后续版本将利用这种分离:版本 3(下一章)将通过从[AbstractTax]派生新类来改变数据源,随后应用程序将被组织成层(第 6 章)。