CS61B 课程笔记（Lecture 10 Subtype Polymorphism vs. HoFs）

1. 多态 (Polymorphism)

多态性是面向对象编程的重要概念之一，指通过一个统一的接口来操作不同类型的实体。Java 中，继承和接口的使用都支持多态。它允许开发人员使用通用代码来处理不同的数据类型和对象，从而实现代码的灵活性和可扩展性。

多态的两种形式：

子类型多态：通过继承，一个子类可以被视为其父类的类型来处理。
接口多态：通过实现接口，多个类可以共享同一个接口，从而在不同的上下文中使用通用的方法。

2. Max 函数与接口

目标：

设计一个可以通用适用于所有 可比较对象（Comparable）的 max 方法。

Java 示例：

定义一个 OurComparable 接口，指定 compareTo 方法：

1
2
3

public interface OurComparable {
    public int compareTo(Object o);
}

compareTo 方法的行为如下：

如果 this < o，返回负数。
如果 this == o，返回 0。
如果 this > o，返回正数。

然后我们实现一个 Dog 类，它实现了 OurComparable 接口：

public class Dog implements OurComparable {
    private String name;
    private int size;

    public Dog(String n, int s) {
        name = n;
        size = s;
    }

    public void bark() {
        System.out.println(name + " says: bark");
    }

    public int compareTo(Object o) {
        Dog otherDog = (Dog) o;
        return this.size - otherDog.size;
    }
}

说明：

Dog 类实现了 compareTo 方法。由于 compareTo 接受任何 Object 类型的参数，因此我们需要将其强制转换为 Dog 类型来进行比较。
在这里，我们根据 size 属性进行比较。

Max 函数的实现：

编写一个通用的 max 方法，适用于所有实现了 OurComparable 接口的对象数组：

public static OurComparable max(OurComparable[] items) {
    int maxDex = 0;
    for (int i = 0; i < items.length; i += 1) {
        int cmp = items[i].compareTo(items[maxDex]);
        if (cmp > 0) {
            maxDex = i;
        }
    }
    return items[maxDex];
}

Max 函数的好处：

代码复用：不需要在每个类中定义专门的 max 方法，比如不需要 Dog.maxDog(Dog[])。
多类型支持：可以对多个类型的对象（只要实现了 OurComparable 接口）进行处理。

3. Comparable 接口

Java 内置的 Comparable<T> 接口允许对象进行“自然排序”，即类自身定义的排序规则。Java 中，Comparable 接口广泛应用于许多库中。

接口定义：

1
2
3

public interface Comparable<T> {
    public int compareTo(T obj);
}

泛型的好处：

通过使用泛型，可以避免将对象强制转换为具体类型（如在 OurComparable 中需要将 Object 转换为 Dog）。

使用 Comparable 的 Dog 类：

public class Dog implements Comparable<Dog> {
    private String name;
    private int size;

    public Dog(String n, int s) {
        name = n;
        size = s;
    }

    public int compareTo(Dog otherDog) {
        return this.size - otherDog.size;
    }
}

4. Comparator 比较器

虽然 Comparable 定义了类的“自然顺序”，但有时我们需要以其他方式对对象进行排序。这时可以使用 Comparator 接口，它允许我们定义不同的排序规则，而不是使用类中的 compareTo 方法。

Comparator 接口：

1
2
3

public interface Comparator<T> {
    int compare(T o1, T o2);
}

Comparator 的比较规则：

如果 o1 < o2，返回负数。
如果 o1 == o2，返回 0。
如果 o1 > o2，返回正数。

实现 Comparator 的 Dog 类：

import java.util.Comparator;

public class Dog implements Comparable<Dog> {
    private String name;
    private int size;

    public int compareTo(Dog otherDog) {
        return this.size - otherDog.size;
    }

    // 定义一个内部静态类，用于按名字排序
    private static class NameComparator implements Comparator<Dog> {
        public int compare(Dog a, Dog b) {
            return a.name.compareTo(b.name);
        }
    }

    // 获取 NameComparator 实例
    public static Comparator<Dog> getNameComparator() {
        return new NameComparator();
    }
}