泛型的 extends

在定義泛型時，可以定義型態的邊界。例如：

class Animal {}
class Human extends Animal {}
class Toy {}
class Duck<T extends Animal> {}

public class BoundDemo {
    public static void main(String[] args) {
        Duck<Animal> ad = new Duck<Animal>();
        Duck<Human> hd = new Duck<Human>();
        Duck<Toy> hd = new Duck<Toy>();  // 編譯錯誤
    }
}

在上例中，使用extends限制指定T實際型態時，必須是Animal的子類別，你可以使用Animal與Human來指定T實際型態，但不可以使用Toy，因為Toy不是Animal的子類別。

一個實際應用可以用快速排序法的例子來說明：

package cc.openhome;

public class Util {
    public static <T extends Comparable> void sort(T[] array) {
        sort(array, 0, array.length-1);
    }
    
    private static <T extends Comparable> void sort(T[] array, int left, int right) {
        if(left < right) { 
            int q = partition(array, left, right); 
            sort(array, left, q-1); 
            sort(array, q+1, right); 
        } 
    }
    
    private static <T extends Comparable> int partition(T[] array, int left, int right) {  
        int i = left - 1; 
        for(int j = left; j < right; j++) {
            if(array[j].compareTo(array[right]) <= 0) {
                i++; 
                swap(array, i, j); 
            } 
        }
        swap(array, i+1, right); 
        return i + 1; 
    } 

    private static <T> void swap(T[] array, int i, int j) {
        T t = array[i]; 
        array[i] = array[j]; 
        array[j] = t;
    }
}

關於快速排序法，可參考 常見程式演算 中的說明。

物件要能排序，基本上物件本身必須能比較大小，因此這個範例要求sort()方法傳入的陣列，當中每個元素必須是T型態，<T extends Comparable>語法限制了T必須實作java.lang.Comparable介面。可以如下使用sort()方法：

String[] words = {"B", "X", "A", "M", "F", "W", "O"};
Util.sort(words);


package cc.openhome;

public class Node<T> {
    public T value;
    public Node<T> next;
    
    public Node(T value, Node<T> next) {
        this.value = value;
        this.next = next;
    }
}

package cc.openhome;

class Fruit {
    int price;
    int weight;
    Fruit() {}
    Fruit(int price, int weight) {
        this.price = price;
        this.weight = weight;
    }
}
class Apple extends Fruit {
    Apple() {}
    Apple(int price, int weight) {
         super(price, weight);
    }
    @Override
    public String toString() {
        return "Apple";
    }
}

class Banana extends Fruit {
    Banana() {}
    Banana(int price, int weight) {
         super(price, weight);
    }
    @Override
    public String toString() {
        return "Banana";
    }
}

package cc.openhome;

public class CovarianceDemo {
    public static void main(String[] args) {
        Node<Apple> apple1 = new Node<>(new Apple(), null);
        Node<Apple> apple2 = new Node<>(new Apple(), apple1);
        Node<Apple> apple3 = new Node<>(new Apple(), apple2);
        
        Node<Banana> banana1 = new Node<>(new Banana(), null);
        Node<Banana> banana2 = new Node<>(new Banana(), banana1);

        printlnForEach(apple3);
        printlnForEach(banana2);
    }
    
    static void printlnForEach(Node<? extends Fruit> n) { 
        Node<? extends Fruit> node = n;
        do {
            System.out.println(node.value);
            node = node.next;
        } while(node != null);
    }
}