[轉載] Java 型態通配字元

轉載自：Java Essence: 我只收這種東西

如果你定義了以下的類別：

1. class Node<T> { 
2.    T value; 
3.    Node<T> next; 
4.  
5.    Node(T value, Node<T> next) { 
6.        this.value = value; 
7.        this.next = next; 
8.    } 
9. } 

class Node<T> {
    T value;
    Node<T> next;

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

如果在以下的例子中：

1. class Fruit {} 
2. class Apple extends Fruit { 
3.    @Override 
4.    public String toString() { 
5.        return "Apple"; 
6.    } 
7. } 
8.  
9. class Banana extends Fruit { 
10.    @Override 
11.    public String toString() { 
12.        return "Banana"; 
13.    } 
14. } 
15.  
16.  
17. public class Main { 
18.    public static void main(String[] args) { 
19.        Node<Apple> apple = new Node<Apple>(new Apple(), null); 
20.        Node<Fruit> fruit = apple;  // 編譯錯誤，incompatible types 
21.    } 
22. } 

class Fruit {}
class Apple extends Fruit {
    @Override
    public String toString() {
        return "Apple";
    }
}

class Banana extends Fruit {
    @Override
    public String toString() {
        return "Banana";
    }
}


public class Main {
    public static void main(String[] args) {
        Node<Apple> apple = new Node<Apple>(new Apple(), null);
        Node<Fruit> fruit = apple;  // 編譯錯誤，incompatible types
    }
}

在範例中，apple 的型態是 Node<Apple>，而 fruit 的型態為 Node<Fruit>，你將 apple 所參考的物件 給 fruit 參考，那麼 Node<Apple> 該是一種 Node<Fruit> 呢？在上例中編譯器給你的答案為「不是」！

如 果 B 是 A 的子型態，而 Node<B> 被視為一種 Node<A> 型態，則稱 Node 具有共變性（Covariance）或有彈性的（flexible）。如 果 Node<A> 被視為一種 Node<B> 型態，則稱 Node 具有逆變性（Contravariance）。如果不具共變性或逆變性，則 Node 是不可變 的（nonvariant）或嚴謹的（rigid）。

Java 的泛型不支援共變性，不過可以使用型態通配字元 ? 與 extends 來宣告變數，使其達到類似共變性，例如：

1. public class Main { 
2.    public static void main(String[] args) { 
3.        Node<Apple> apple = new Node<Apple>(new Apple(), null); 
4.        Node<? extends Fruit> fruit = apple; // 類似共變性效果 
5.    } 
6. } 

public class Main {
    public static void main(String[] args) {
        Node<Apple> apple = new Node<Apple>(new Apple(), null);
        Node<? extends Fruit> fruit = apple; // 類似共變性效果
    }
}

一個實際應用的例子是：

1. public class Main { 
2.    public static void main(String[] args) { 
3.        Node<Apple> apple1 = new Node<Apple>(new Apple(), null); 
4.        Node<Apple> apple2 = new Node<Apple>(new Apple(), apple1); 
5.        Node<Apple> apple3 = new Node<Apple>(new Apple(), apple2); 
6.  
7.        Node<Banana> banana1 = new Node<Banana>(new Banana(), null); 
8.        Node<Banana> banana2 = new Node<Banana>(new Banana(), banana1); 
9.  
10.        show(apple3); 
11.        show(banana2); 
12.    } 
13.  
14.    static void show(Node<? extends Fruit> n) { 
15.        Node<? extends Fruit> node = n; 
16.        do { 
17.            System.out.println(node.value); 
18.            node = node.next; 
19.        } while(node != null); 
20.    } 
21. } 

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

        Node<Banana> banana1 = new Node<Banana>(new Banana(), null);
        Node<Banana> banana2 = new Node<Banana>(new Banana(), banana1);

        show(apple3);
        show(banana2);
    }

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

你的目的是可以顯示所有的水果節點，由於 show() 方法使用型態通配字元宣告參數，使得 n 具備類似共變性的效果，因此 show() 方法就可以顯示 Node<Apple> 也可以顯示 Node<Banana>。

Java 的泛型亦不支援逆變性，不過可以使用型態通配字元 ? 與 super 來宣告變數，使其達到類似逆變性，例如：

1. public class Main { 
2.    public static void main(String[] args) { 
3.        Node<Fruit> fruit = new Node<Fruit>(new Fruit(), null); 
4.        Node<? super Apple> apple = fruit; 
5.        Node<? super Banana> banana = fruit; 
6.    } 
7. } 

public class Main {
    public static void main(String[] args) {
        Node<Fruit> fruit = new Node<Fruit>(new Fruit(), null);
        Node<? super Apple> apple = fruit;
        Node<? super Banana> banana = fruit;
    }
}

一個實際應用的例子如下：

1. class Fruit { 
2.    int price; 
3.    int weight; 
4.    Fruit(int price, int weight) { 
5.        this.price = price; 
6.        this.weight = weight; 
7.    } 
8. } 
9.  
10. class Apple extends Fruit { 
11.     Apple(int price, int weight) { 
12.         super(price, weight); 
13.     } 
14. } 
15.  
16. class Banana extends Fruit { 
17.     Banana(int price, int weight) { 
18.         super(price, weight); 
19.     } 
20. } 
21.  
22. interface Comparator<T> { 
23.    int compare(T t1, T t2); 
24. } 
25.  
26. class Basket<T> { 
27.    private T[] things; 
28.    Basket(T... things) { 
29.        this.things = things; 
30.    } 
31.    void sort(Comparator<? super T> comparator) { 
32.        // 作一些排序 
33.    } 
34. } 

class Fruit {
    int price;
    int weight;
    Fruit(int price, int weight) {
        this.price = price;
        this.weight = weight;
    }
}

class Apple extends Fruit {
     Apple(int price, int weight) {
         super(price, weight);
     }
}

class Banana extends Fruit {
     Banana(int price, int weight) {
         super(price, weight);
     }
}

interface Comparator<T> {
    int compare(T t1, T t2);
}

class Basket<T> {
    private T[] things;
    Basket(T... things) {
        this.things = things;
    }
    void sort(Comparator<? super T> comparator) {
        // 作一些排序
    }
}

籃子（Basket）中可以置放各種物品，並可以傳入一個比較器（Comparator）進行排序。假設你分別在兩個籃子中放置了蘋果（Apple）與香蕉（Banana）：

1. public class Main { 
2.    public static void main(String[] args) { 
3.        Comparator<Fruit> comparator = new Comparator<Fruit>() { 
4.            public int compare(Fruit f1, Fruit f2) { 
5.                return f1.price - f2.price; 
6.            } 
7.        }; 
8.        Basket<Apple> b1 = new Basket<Apple>( 
9.            new Apple(20, 100), new Apple(25, 150) 
10.        ); 
11.        Basket<Banana> b2 = new Basket<Banana>( 
12.            new Banana(30, 200), new Banana(25, 250) 
13.        ); 
14.        b1.sort(comparator); 
15.        b2.sort(comparator); 
16.    } 
17. } 

public class Main {
    public static void main(String[] args) {
        Comparator<Fruit> comparator = new Comparator<Fruit>() {
            public int compare(Fruit f1, Fruit f2) {
                return f1.price - f2.price;
            }
        };
        Basket<Apple> b1 = new Basket<Apple>(
            new Apple(20, 100), new Apple(25, 150)
        );
        Basket<Banana> b2 = new Basket<Banana>(
            new Banana(30, 200), new Banana(25, 250)
        );
        b1.sort(comparator);
        b2.sort(comparator);
    }
}

現在 b1 的型態為 Basket<Apple>，而 b2 的型態為 Basket<Banana>，你可以如上實作一個水果（Fruit）比較器，比較水果的價格進行排序，這可以同時適用於 Basket<Apple> 與 Basket<Banana>。