java - 当使用组合而不是继承时，Comparator<T> 的替代方案是什么？

Question

在重构 Java 项目以使用组合而不使用继承时，我仍然存在执行集合的多态排序的问题。

继承示例:

public class AClass
{
    private List<OneClassOfManyThatRequireSortedInstances> unsortedList;

    public List<OneClassOfManyThatRequireSortedInstances> getSortedList()
    {
        List<OneClassOfManyThatRequireSortedInstances> sortedList = new ArrayList(this.unsortedList);
        Collections.sort(sortedList, SuperClassOfManyThatRequireSortedInstances.orderComparator);

        return sortedList;
    }
}

现在，重构之后；类 OneClassOfManyThatRequireSortedInstances 不再继承自抽象 SuperClassOfManyThatRequireSortedInstances 但 Collections.sort() 需要相互比较的实例。

重构它的最佳方法是什么？

编辑:

为了完整性；我添加了 Comparator 实现并进一步澄清了问题。

public class SuperClassOfManyThatRequireSortedInstances
{
    private int order;

    public static final Comparator<SuperClassOfManyThatRequireSortedInstances> orderComparator = new Comparator<SuperClassOfManyThatRequireSortedInstances>()
    {
        public int compare(SuperClassOfManyThatRequireSortedInstances o1, SuperClassOfManyThatRequireSortedInstances o2)
        {
            if ((o1 == null) && (o2 == null))
            {
                return 0;
            }
            if (o1 == null)
            {
                return -1;
            }
            if (o2 == null)
            {
                return 1;
            }
            return (new Integer(o1.getOrder()).compareTo(new Integer(o2
                .getOrder())));
        }
    };


    public int getOrder()
    {
        return this.order;
    }


    public void setOrder(int order)
    {
        this.order = order;
    }
}

问题的症结在于，在重构为组合之后，OneClassOfManyThatRequireSortedInstances 不再是 "is a" SuperClassOfManyThatRequireSortedInstances 因此代码被破坏.

许多类，例如 OneClassOfManyThatRequireSortedInstances 不再有共同的父类。因此，Collections.sort() 不能仅通过 Comparator 的单个实现跨这些类使用。 OneClassOfManyThatRequireSortedInstances 这样的类现在有一个 SuperClassOfManyThatRequireSortedInstances 成员； “有一个” 关系。

Answer 1

假设有两个类，Car 和 Train。你可以创建一个像

这样的接口(interface)

public interface SpeedProvider {
    int getSpeed();
}

然后Car和Train都实现了SpeedProvider接口(interface)

public class Car implements SpeedProvider {
    int maxSpeed = 220;

    @Override
    public int getSpeed() {
        return maxSpeed;
    }
}

public class Train implements SpeedProvider {
    int maxSpeed = 300;

    @Override
    public int getSpeed() {
        return maxSpeed;
    }
}

最后，您可以实现一个 Comparator 来比较两个 SpeedProvider

public class VehicleComparator implements Comparator<SpeedProvider> {
    @Override
    public int compare(SpeedProvider o1, SpeedProvider o2) {
        /* ... */
        return 0;
    }
}