Java 泛型進階：深度解析 <T extends Comparable<? super T>> 類型參數聲明

核心問題：為什麼不直接用 <T extends Comparable<T>>？

在 Collections.sort() 等工具方法中，常見聲明：

public static <T extends Comparable<? super T>> void sort(List<T> list)

看似複雜，實則解決繼承體系中比較邏輯復用的關鍵問題。

兩種聲明的關鍵差異

實戰代碼驗證

場景：Animal → Dog 繼承體系

class Animal implements Comparable<Animal> {
    protected int age;
    public Animal(int age) { this.age = age; }
    @Override public int compareTo(Animal other) { return this.age - other.age; }
}

class Dog extends Animal {
    public Dog(int age) { super(age); }
    // 未實現 Comparable<Dog>，繼承 Comparable<Animal>
}

測試 <T extends Comparable<T>> 版本

public static <T extends Comparable<T>> void sortV1(List<T> list) {
    Collections.sort(list);
}

List<Animal> animals = Arrays.asList(new Animal(5), new Animal(3));
List<Dog> dogs = Arrays.asList(new Dog(2), new Dog(4));

sortV1(animals); // ✅ 編譯通過：Animal implements Comparable<Animal>
sortV1(dogs);    // ❌ 編譯錯誤：Dog 未實現 Comparable<Dog>

錯誤原因：Dog 繼承自 Animal，擁有 Comparable<Animal>，但 Comparable<Dog> 不存在。Java 不允許類別實現兩個不同參數化的同一介面（Comparable<Animal> 和 Comparable<Dog>）。

測試 <T extends Comparable<? super T>> 版本

public static <T extends Comparable<? super T>> void sortV2(List<T> list) {
    Collections.sort(list);
}

sortV2(animals); // ✅ Animal implements Comparable<Animal>，Animal 是 Animal 的 super type
sortV2(dogs);    // ✅ Dog 繼承 Comparable<Animal>，Animal 是 Dog 的 super type

通過原因：? super T 表示 T 或 T 的任意父類型。Dog 擁有 Comparable<Animal>，而 Animal 是 Dog 的父類型，滿足 ? super Dog。

PECS 原則：Producer Extends, Consumer Super

Effective Java Item 28 核心指導原則：

• Producer (生產者/只讀)：使用 extends → List<? extends T>
• Consumer (消費者/只寫)：使用 super → List<? super T>

應用到 Comparable

• Comparable 的 compareTo(T other) 是消費者角色（消費 T 類型參數）
• 因此使用 ? super T：接受 T 或其父類型
• 這使得 Comparable<Animal> 可作為 Comparable<? super Dog> 使用

JDK 實際案例：java.util.Date vs java.sql.Date

public class java.util.Date implements Comparable<java.util.Date> { ... }
public class java.sql.Date extends java.util.Date { ... }

• java.sql.Date 繼承 java.util.Date，自動擁有 Comparable<java.util.Date>
• java.sql.Date 無法再 implements Comparable<java.sql.Date>（介面衝突）
• 排序 List<java.sql.Date> 只能用 <T extends Comparable<? super T>> 版本

類型參數 vs 通配符：何時用 T？

// 使用類型參數 T：需在多處引用同一類型
public <T extends Comparable<? super T>> T findMax(T candidate, List<T> list) {
    for (T element : list) {
        if (element.compareTo(candidate) > 0) return element;
    }
    return candidate;
}

// 僅用通配符：不需引用類型，僅限制參數
public void sortOnly(List<? extends Comparable<? super ?>> list) {
    Collections.sort(list); // 編譯錯誤！sort 需要具體 T
}

// 正確：sort 簽名需要類型參數
public static <T extends Comparable<? super T>> void sort(List<T> list)

關鍵差異

• 類型參數 T：可用於返回型別、方法體內變數、多參數關聯
• 通配符 ?：僅用於參數限制，無法在方法體內引用具體類型

多類型參數關聯

// S 是 T 的子類型
public <T, S extends T> T copy(S source) {
    return source; // S 可作為 T 返回
}

// 實際應用：Collections.copy
public static <T> void copy(List<? super T> dest, List<? extends T> src)

腦力激盪：常見誤區

總結

1. <T extends Comparable<? super T>> 是API 靈活性與類型安全的最佳平衡
2. 支援繼承體系中比較邏輯復用，避免強制子類重複實現 Comparable
3. 遵循 PECS 原則：Comparable 作為消費者使用 super
4. 類型參數 T 用於多處引用同一類型，通配符 ? 用於單純參數限制
5. 掌握此模式，能設計出更健壯、可復用的泛型 API