Java 多态性：如何避免类型转换输入参数？

Question

假设我们有一个带有 compare() 函数的 Parent 接口。

public interface Parent {
    public int compare(Parent otherParent);
}

假设孩子Child1、Child2、Child3实现了这个接口Parent

public class Child1 implements Parent {
    @Override
    public int compare(Parent other) {
        Child1 otherChild = (Child1)other;
    }
}

另外，我在代码中的其他任何地方都使用泛型<T extends Parent>。所以我需要从代码的其他部分比较两个类型为 T 的对象。

我知道这是一个糟糕的设计，因为我在 compare() 函数中对 Parent 对象进行类型转换，我什至不知道输入是否属于 Child1 类型。

在使用泛型时如何避免这种类型转换？

Answer 1

为什么不这样？

interface Parent<T extends Parent<?>> {
    int compare(T type);
}

class Child1 implements Parent<Child1>{

    @Override
    public int compare(Child1 type) {
        return 0;
    }
}

编辑：为确保正确使用，您可以使用

interface Parent<T extends Parent<T>>{ /* ... */ }   //instead of wildcard

但老实说，“循环”看起来并不漂亮，并且由于 Java 中的泛型在运行时不起作用 (more information)，因此对于您称为“糟糕设计”的同一个演员，它们本质上是句法糖" 所以我不认为你目前的方法不好。

Answer 2

答案取决于您如何处理继承层次结构：

• 如果派生类必须仅与它们自己的类的实例进行比较，并且允许在呈现不同类的对象时抛出错误，请使用强制转换，但通过检查 instanceof 来保护它
• 如果必须跨类型边界比较派生类，则需要更复杂的策略来避免强制转换：您可以使用类似访问者的模式来实现执行比较所需的双重分派。

这是一个使用抽象类的示例实现：

// Use this class as the base class of your Child classes
class AbstractChild implements Parent {
    @Override
    public int compare(Parent otherObj) {
        if (!()) {
            throw new IllegalStateException("Unexpected implementation of Child");
        }
        AbstractChild other = (AbstractChild)otherObj;
        return doCompare(other);
    }
    protected abstract int doCompare(AbstractChild other);
    protected abstract int accept(Child1 c1);
    protected abstract int accept(Child2 c2);
    protected abstract int accept(Child3 c3);
}
class Child1 extends AbstractChild {
    @Override
    protected int doCompare(AbstractChild other) {
         return other.accept(this);
    }
    @Override
    protected int accept(Child1 c1) {
        // Compare c1 instance to this object
    }
    @Override
    protected int accept(Child2 c2) {
        // Compare c2 instance to this object
    }
    @Override
    protected int accept(Child3 c3) {
        // Compare c3 instance to this object
    }
}
class Child2 extends AbstractChild {
    @Override
    protected int doCompare(AbstractChild other) {
         return other.accept(this);
    }
    @Override
    protected int accept(Child1 c1) {
        // Compare c1 instance to this object
    }
    @Override
    protected int accept(Child2 c2) {
        // Compare c2 instance to this object
    }
    @Override
    protected int accept(Child3 c3) {
        // Compare c3 instance to this object
    }
}
class Child3 extends AbstractChild {
    @Override
    protected int doCompare(AbstractChild other) {
         return other.accept(this);
    }
    @Override
    protected int accept(Child1 c1) {
        // Compare c1 instance to this object
    }
    @Override
    protected int accept(Child2 c2) {
        // Compare c2 instance to this object
    }
    @Override
    protected int accept(Child3 c3) {
        // Compare c3 instance to this object
    }
}

这种方法的唯一转换是在抽象类级别。实际比较逻辑的实现包含在accept 方法中，其中在两个已知类型的对象之间进行比较。

Answer 3

你不能。 Java 接口正是顾名思义——一个指示接受类型的接口；因此在编译时需要完全与接口中定义的方法签名相同。

是的，将其转换回 Child 类型感觉像是糟糕的设计 - 但它确实是 Java 规定的糟糕设计，所以这不是你的错。

Answer 4

在一般情况下你无法避免它。但是，如果子类的数量是固定的，您可以应用类似于访问者模式的方法来避免强制转换，但会以编写更多代码为代价：

interface Parent {
   int compare(Parent p);
   protected int compareWith(Child1 c);
   protected int compareWith(Child2 c);
   protected int compareWith(Child3 c);
}

class Child1 implements Parent {
    @Override int compare(Parent p) {
        return p.compareWith(this);
    }
    @Override int compareWith(Child1 c) {
       //specific code to child1
    }
    @Override int compareWith(Child2 c) {
       //specific code to child2
    }
    @Override int compareWith(Child3 c) {
       //specific code to child3
    }
}
// and so on for the other children

这确实避免了强制转换，但我不确定在您在这里介绍的情况下额外的努力是否值得。

Answer 5

您在那里描述的模式正是Comparable 的模式。实际上，您应该考虑省略您的Parent 接口，而将其替换为Comparable。

Comparable 接口及其使用也展示了如何解决这个问题：类型可以作为参数给出，以确保只有匹配的类型可以传递给compare 方法：

interface Parent<T> {
    int compare(T that);
}

class Child1 implements Parent<Child1> {
    @Override
    public int compare(Child1 that) {
        ...
    }
}

对于所有其他情况，您至少必须考虑将不同的Child-classes 相互比较时会发生什么：

Child1 c1 = new Child1();
Child2 c2 = new Child2();

// Should this be possible? What should happen here? 
// How should different child classes be compared?
c1.compare(c2);