Java子类重写compareTo方法的契约陷阱与Comparator解决方案

class Parent implements Comparable<Parent> {
    int x;

    public Parent(int x) {
        this.x = x;
    }

    /** 按照x的值进行排序 */
    @Override
    public int compareTo(Parent other) {
        return Integer.compare(this.x, other.x);
    }

    @Override
    public String toString() {
        return "Parent(x=" + x + ")";
    }
}

class Child extends Parent { // 注意：这里不应该直接实现Comparable<Child>
    int y;

    public Child(int x, int y) {
        super(x);
        this.y = y;
    }

    // 假设我们尝试这样做，但这是错误的：
    // @Override
    // public int compareTo(Child other) { // 编译错误：方法签名不兼容
    //     int c = super.compareTo(other); // 这里other是Child类型，但super.compareTo期望Parent
    //     if (c != 0) return c;
    //     return Integer.compare(this.y, other.y);
    // }

    @Override
    public String toString() {
        return "Child(x=" + x + ", y=" + y + ")";
    }
}

Parent p = new Parent(10);
Child c = new Child(10, 5);
Child d = new Child(10, 20);

import java.util.Comparator;
import java.util.TreeSet;

// Parent 和 Child 类定义如上...

public class ComparisonExample {
    public static void main(String[] args) {
        Parent p = new Parent(10);
        Child c = new Child(10, 5);
        Child d = new Child(10, 20);
        Parent p2 = new Parent(5);
        Child c2 = new Child(5, 15);

        // 使用自定义Comparator来排序Parent及其子类实例
        Comparator<Parent> customParentChildComparator = (obj1, obj2) -> {
            // 首先比较Parent的x值
            int compareX = Integer.compare(obj1.x, obj2.x);
            if (compareX != 0) {
                return compareX; // x值不同，直接返回比较结果
            }

            // 如果x值相同，则进一步根据类型和y值进行比较
            // 规则：Parent实例排在Child实例之前（当x值相等时）
            // 两个Parent实例：相等
            // 两个Child实例：比较y值
            // Parent vs Child：Parent在前

            boolean isObj1Child = obj1 instanceof Child;
            boolean isObj2Child = obj2 instanceof Child;

            if (isObj1Child && !isObj2Child) {
                return 1; // obj1是Child，obj2是Parent，Child排在Parent后面
            }
            if (!isObj1Child && isObj2Child) {
                return -1; // obj1是Parent，obj2是Child，Parent排在Child前面
            }

            // 此时，要么都是Parent，要么都是Child
            if (isObj1Child && isObj2Child) {
                // 都是Child类型，比较y值
                return Integer.compare(((Child) obj1).y, ((Child) obj2).y);
            }

            // 都是Parent类型（或x值相同且类型相同，且都不是Child），视为相等
            return 0;
        };

        // 使用这个Comparator创建TreeSet，或用于Collections.sort()
        TreeSet<Parent> mySortedSet = new TreeSet<>(customParentChildComparator);
        mySortedSet.add(p);
        mySortedSet.add(c);
        mySortedSet.add(d);
        mySortedSet.add(p2);
        mySortedSet.add(c2);

        System.out.println("使用自定义Comparator排序后的集合：");
        for (Parent item : mySortedSet) {
            System.out.println(item);
        }
        // 预期输出顺序 (x升序，x相同时Parent在前，Child在后且y升序):
        // Parent(x=5)
        // Child(x=5, y=15)
        // Parent(x=10)
        // Child(x=10, y=5)
        // Child(x=10, y=20)
    }
}