比较 Java 子类

Question

我的应用可能会比较同一抽象父类的任意两个子类的实例。我希望它们进行如下比较：

1. 如果它们是不同的子类，则应由父类进行比较。
2. 如果它们是同一个子类，则子类应该进行比较。

类将通过 TreeMap 进行比较，因此我可以选择使用 Comparator 或实现 Comparable（或两者兼而有之？）。

我可以想到几种方法来做到这一点，但它们都有些混乱且容易出错。有没有优雅的解决方案？

提前谢谢...

Answer 1

你可以试试

// Parent:
@Override
public final int compareTo(Parent other)
{
  if (getClass() == other.getClasss()) {
    // same type -> pass it to subclass implementation
    return this.subCompare(other)
  }

  // different type -> do the comparison here based on Parent's logic
  // ...
}

protected int subCompare(Parent other)
{
  // this should not be called directly
  return 0; // could throw an exception here too
}

// Derived1:
@Override
protected int subCompare(Parent other)
{
  // this method is only called from Parent
  Derived1 other1 = (Derived1) other;
  // do the comparison based on Derived1's logic
}

其他派生类也是如此

Answer 2

这不是您问题的直接答案，而是：
我相信您所做的事情容易出错且存在问题。
compareTo 方法施加的相等性测试通常应该返回与equals 方法相同的结果。 IE。 compareTo 方法强加的排序应该与equals一致。
如果违反本合同，您可能会遇到排序集合（您正在使用）的问题。
我为什么这么说：
在某些情况下您希望将比较委托给父类这一事实表明您已在子类中添加了一个值组件。
如果您这样做了，则无法保留 equals 合同，并且您可能会遇到排序容器的问题（见上文）

Answer 3

无论哪种方式都容易出错。你可以在你的子类中做这样的事情：

类子类1 ... {

public boolean equals(Object o) {
  if(o instanceof Subclass1) {
    return super.equals(o);
  }

  ... compare subclasses
}

}

Answer 4

类层次结构是否应该可扩展？
=> 如果它不可扩展（或很少会扩展），你可以实现一个 Comperator 以便所有比较代码都在一个地方。

排序对象的方法不止一种吗？ => 如果是这样，那么您将不得不为每个订单使用一个比较器。

compareTo(other)（或compare(o1, o2)）从三种情况调用：

1. this instanceof other.class（即o1 instanceof o2.class）：
   • this.class 应该比较 this 和 o2，因为它比 other.class 包含更多信息；
2. other instanceof this.class（即o2 instanceof o1.class）：
   • other.class 应该比较 other 和 this 并且 this.class.compareTo 应该翻转结果并返回它。
3. 存在第一个共同祖先 P 使得this instanceof P && other instanceof P:
   • P 应该比较 this 和 other：递归调用 super.compareTo(other) 并返回结果。

Answer 5

这就是我现在的做法。我认为这将变得非常优雅：

public abstract class ParentClass implements Comparable<ParentClass> {
    // compareTo(ParentClass) is implicitly abstract
}


public class SubClass1 extends ParentClass /* Comparable<> is implicitly implemented */ {
    @Override
    public int compareTo(ParentClass another) {
        SubClass1 subAnother = (SubClass1) another;
        return /* result of sub-class comparison */;
    }
}


public class MyComparator implements Comparator<ParentClass> {
    @Override
    public int compare(ParentClass lhs, ParentClass rhs) {

        // Are lhs and rhs instances of the same sub-class?
        if(!lhs.getClass().equals(rhs.getClass()))
            // They are different. Use parent class comparison.
            return /* result of parent class comparison */;

        // They are the same. Use sub-class comparison.
        return lhs.compareTo(rhs);
    }
}

然后我只是将MyComparator 的一个实例传递给TreeMap。它处理不同子类的比较，如果它们相同，则将比较传递给子类。

如果another 是另一个子类的实例，我不喜欢SubClass1.compareTo() 会抛出ClassCastException。不过我不必担心这一点，只要我确保子类仅通过MyComparator 进行比较。