什么时候动态多态是必要的（与静态多态相比）？

Question

• 当我们使用有对象的子类型系统时，我们不能决定它的实际类型（例如，我们有一个包含许多不同类型对象的容器。但是，在这种情况下，为什么不尝试代数数据类型或联合类型来建模容器的元素类型呢？）。
• 我们只有对象，我们不知道它的方法的真实名称，所以我们必须使用vptr表来帮助我们。

Answer 1

在Haskell中，我们用高阶函数代替“动态多态性”。

考虑以下问题：我们希望定义一个表示谓词的类型。我们最终将在实现列表时使用此类型谓词，以便定义过滤器函数。我们希望能够轻松地定义相等谓词，即小于谓词，并且能够通过用“and”连接两个谓词来组合它们。

合理的Java尝试如下所示。

interface Predicate<T> {
    public abstract boolean predicate(T x);
}

class EqualsPredicate<T> implements Predicate<T> {
    private final T value;

    public EqualsPredicate(T value) {
        this.value = value;
    }

    @Override
    public boolean predicate(T x) {
        return this.value.equals(x);
    }
}

class LessPredicate<T implements Comparable<T>> implements Predicate<T>{
    private final T value;

    public LessPredicate(T value) {
        this.value = value;
    }

    @Override
    public boolean predicate(T x) {
        return this.value.compareTo(x) < 0;
    }
}

class AndPredicate<T> implements Predicate<T> {
    private final Predicate<T> p1;
    private final Predicate<T> p2;

    public AndPredicate(Predicate<T> p1, Predicate<T> p2) {
        this.p1 = p1;
        this.p2 = p2;
    }

    @Override
    public boolean predicate(T x) {
        return p1.predicate(x) && p2.predicate(x);
    }
}

type Predicate t = t -> Bool

makeEqualsPredicate :: Eq t => t -> Predicate t
makeEqualsPredicate = (==)

makeLessPredicate :: Ord t => t -> Predicate t
makeLessPredicate = (<)

makeAndPredicate :: Predicate t -> Predicate t -> Predicate t
makeAndPredicate p1 p2 x = p1 x && p2 x
-- or, even more succinctly, makeAndPredicate = liftA2 (&&)

但是等等，你说。谓词是一个只有一个方法的接口。如果我们想有两种方法，我们应该怎么做？

如果有一个方法的接口对应一个函数，那么有两个方法的接口必须对应一对函数。这就是所谓的“组合重于继承”的OOP原则。

所以我们总是可以用Haskell风格的高阶函数代替Java风格的动态多态性。

@FunctionalInterface
interface Predicate<T> {
    public abstract boolean predicate(T x);

    public static Predicate<J> makeEqualsPredicate(J t) {
        return (x) -> t.equals(x);
    }

    public static Predicate<J implements Comparable<J>> makeLessPredicate(J t) {
        return (x) -> t.compareTo(x) < 0;
    }

    public Predicate<T> makeAndPredicate(Predicate<T> other) {
        return (x) -> this.predicate(x) && other.predicate(x);
    }
}