CS61B笔记-4.3 Subtype Polymorphism（Comparable, Comparator

子类继承多态

本章主要学习Comparable 和 Comparator。

一、引入：使用interface inheritance（接口继承）OurComparable帮助简化比较的代码。

创建OurComparable接口包含compareTo方法，满足所有类型的对象 -->因此需要用到<T>。

【⭐️重点1⭐️】：接口名作为形参和返回值

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

当dog类 implements OurComparable接口，max方法的形参和返回对象就可以写OurComparable[] items。

【为什么接口可以当对象？：虽然接口不能直接实例化，但是接口可以被其他类实现（implement），因此可以通过一个实现了该接口的类的实例来代表该接口对象。】

• 方法的形参是接口名，其实需要的是该接口的实现类对象。
• 方法的返回值是接口名，其实返回的是该接口的实现类对象。

【算一种多态，面向接口编程】

额外tips: 由于多态，可以这样写： 左边 接口 = 右边 接口的实现类

----------------------------------------------------------------------------------------------

【⭐️重点2⭐️】：如果不写implements OurComparable哪里会无法compile？

 

因为max方法只接受OurComparable对象

【主要是理解这几个类之间的关系，

创建顺序：先接口Comparable,再Dog implements接口，并重写方法compareTo，再创建Maximizer写max方法；最后DogLauncher的main方法。

注意DogLauncher是单独的一个类来包含main方法。】

【⭐️重点3⭐️】

在Dog类中的重写compareTo方法的时候，要写 ：Dog unique = (Dog) o;

因为o是object，object中没有size, 如果是o.size无法识别，所以要cast

 @Override
    public int compareTo(Object o) {
        Dog unique = (Dog) o; //因为o是object，object中没有size,
        // 如果是o.size无法识别，所以要cast
        return this.size - unique.size;
    }
}

二、升级：使用Java自带接口Comparable<T>替换OurComparable接口

三、再升级：

1.0版本：使用Comparator

引入：Since a comparator is an object, the way we'll use Comparator is by writing a nested class inside Dog that implements the Comparator interface.

因为comparator是一个object类，需要在Dog类里定一个内嵌类implements Comparator接口，然后重写compare方法，自定义比较方法

public static class NameComparator implements Comparator<Dog> {
    @Override
    public int compare(Dog o1, Dog o2) {
        return o1.name.compareTo(o2.name);
    }
}

【待解决问题❓】这里的类一定是static，不然idea会报错

然后在DogLauncher的main方法中添加以下，得到结果。

Dog.NameComparator nc = new Dog.NameComparator();
if(nc.compare(dogs[0], dogs[1]) > 0) {
    dogs[0].bark();
}
dogs[1].bark();

2.0版本改进：private此Comparator，再public一个get此Comparator

为了符合美观性，将构造器private，

【待解决❓NameComparator也得是static的原因】

private static class NameComparator implements Comparator<Dog> {
    @Override
    public int compare(Dog o1, Dog o2) {
        return o1.name.compareTo(o2.name);
    }
}
public static NameComparator getNameComparator() {
    return new NameComparator();
}

DogLauncher中变成:

Dog.NameComparator nc =  Dog.getNameComparator();
if(nc.compare(dogs[0], dogs[1]) > 0) {
    dogs[0].bark();
}
dogs[1].bark();

但是Dog.NameComparator报错，因为NameComparator是private,所以改为

Comparator<Dog> nc =  Dog.getNameComparator();

总结

Comparator实现的类 是写在dog类里的嵌套类。
Comparable实现的类 是dog类。