Java泛型(6)：extends和super關鍵字

(1) <T extends A>

因為擦除移除了類型信息，而無界的泛型參數調用的方法只等同於Object。但是我們可以限定這個泛型參數為某個類型A的子集，這樣泛型參數聲明的引用就可以用類型A的方法了，語法為<T extends A>。下面是一個例子：

// 超能
interface SuperPower { }
// 千里眼
interface SuperVision extends SuperPower { void see(); }
// 順風耳
interface SuperHearing extends SuperPower { void hear(); }

// 超級英雄
class SuperHero<P extends SuperPower> {
    P power;
    SuperHero(P power) { this.power = power; }
    P getPower() { return power; }
}

// 只會千里眼的英雄
class SuperVisionMan<P extends SuperVision> extends SuperHero<P> {
    SuperVisionMan(P power) { super(power); }
    void see() { power.see(); }
}

// 只會順風耳的英雄
class SuperHearingMan<P extends SuperHearing> extends SuperHero<P> {
    SuperHearingMan(P power) { super(power); }
    void hear() { power.hear(); }
}

// 都會的的英雄
class SuperAllSkillsMan<P extends SuperVision & SuperHearing> extends SuperHero<P> {
    SuperAllSkillsMan(P power) { super(power); }
    void see() { power.see(); }
    void hear() { power.hear(); }
}

class SampleSuperVision implements SuperVision{
    @Override
    public void see() { System.out.println("I can see anything!"); }
}

class SampleSuperHearing implements SuperHearing{
    @Override
    public void hear() { System.out.println("I can hear anything!"); }
}

class SampleSuperAllSkills implements SuperVision, SuperHearing{
    @Override
    public void see() { System.out.println("I'm good at all skills and i can see anything!"); }
    @Override
    public void hear() { System.out.println("I'm good at all skills and i can hear anything!"); }
}

public class EpicBattle {
    public static void main(String[] args) {
        SuperVisionMan<SuperVision> man1 = new SuperVisionMan<>(new SampleSuperVision());
        man1.see(); // I can see anything!
        SuperHearingMan<SuperHearing> man2 = new SuperHearingMan<>(new SampleSuperHearing());
        man2.hear(); // I can hear anything!
        SuperAllSkillsMan<SampleSuperAllSkills> man3 = new SuperAllSkillsMan<>(new SampleSuperAllSkills());
        man3.see(); // I'm good at all skills and i can see anything!
        man3.hear(); // I'm good at all skills and i can hear anything!
    }
}

 

(2) <? extends T> / <? super T>

前置條件：

class Fruit {
    private String name;
    public Fruit(String name) { this.name = name; }
    public String getName() { return name; }
    @Override public String toString() { return name; }
}
class Apple extends Fruit {
    public Apple(String name) { super(name); }
}

class RedFushi extends Apple {
    public RedFushi(String name) { super(name); }
}

class Orange extends Fruit {
    public Orange(String name) { super(name); }
}

我們先研究一種特殊的數組行為：可以向導出類的數組賦予基本類型的數組引用。這種行為是可以的。但是，如果往這個導出類的數組中插入其他類型的值(extends 基本類型)，編譯期不會報錯，但是運行期則會報錯。

Fruit[] fruits = new Apple[10];
fruits[0] = new Apple("Apple1");
fruits[1] = new Orange("Orange1"); // Compile OK; Run java.lang.ArrayStoreException.

如果替換成List容器，則編譯期就會報錯。原因與向上轉型(Apple->Fruit)無關，根本原因在於ArrayList<Apple>和List<Fruit>不是同一類型。

List<Fruit> fruitList = new ArrayList<Apple>(); // [Compile ERROR] Type mismatch: cannot convert from ArrayList<Apple> to List<Fruit>

通過使用通配符<? extends Fruit>可以解決這個問題。 Apple是Fruit的子類型，則List<Apple>是 List<? extends Fruit>的子類型。但是一旦執行了這種向上轉型，就失去了向其中傳入任何對象的能力。你不能夠往一個使用了<? extends T>的數據結構里寫入任何的值。原因非常的簡單，你可以這樣想：這個<? extends Fruit>通配符告訴編譯器我們在處理一個類型Fruit的子類型，但我們不知道這個子類型究竟是什么。因為沒法確定，為了保證類型安全，我們就不允許往里面加入任何這種類型的數據。但是可以get到Fruit類型的元素對象。

List<? extends Fruit> fruitList1 = new ArrayList<Apple>();
fruitList1.add(new Apple("Apple1")); // [Compile ERROR] The method add(capture#1-of ? extends Fruit) in the type List<capture#1-of ? extends Fruit> is not applicable for the arguments (Apple)
fruitList1.add(new Object()); // [Compile ERROR] The method add(capture#2-of ?extends Fruit) in the type List<capture#2-of ? extends Fruit> is not applicable for the arguments (Object)

可以使用下面的方法代替：

List<Apple> tmpList1 = new ArrayList<>(Arrays.asList(new Apple("Apple1"), new Apple("Apple2")));
fruitList1 = tmpList1;
System.out.println(fruitList1.get(0) + "/" + fruitList1.get(1)); // Apple1/Apple2
List<Orange> tmpList2 = new ArrayList<Orange>(Arrays.asList(new Orange("Orange1"), new Orange("Orange2")));
fruitList1 = tmpList2;
System.out.println(fruitList1.get(0) + "/" + fruitList1.get(1)); // Orange1/Orange2

也可以通過逆變使用超類型通配符，Fruit是Apple的父類型，則List<Fruit>是List<? super Apple>的子類型。

List<? super Apple> fruitList2 = new ArrayList<Fruit>();
fruitList2.add(new Apple("Apple1"));
fruitList2.add(new RedFushi("RedFushi1"));
fruitList2.add(new Orange("Orange1")); // [Compile ERROR] The method add(capture#9-of ? super Apple) in the type List<capture#9-of ? super Apple> is not applicable for the arguments (Orange)
fruitList2.add(new Fruit("Fruit1")); // [Compile ERROR] The method add(capture#9-of ? super Apple) in the type List<capture#9-of ? super Apple> is not applicable for the arguments (Fruit)

(3) PECS法則

總結<? extends T>/<? super T>通配符的特征，我們可以得出以下結論：

1. 如果你想在方法中從input參數里獲取數據，使用<? extends T>通配符

2. 如果你想在方法中把對象寫入一個input參數中，使用<? super T>通配符

3. 如果你既想存，又想取，那就別用通配符

PECS指“Producer Extends，Consumer Super”。換句話說，如果方法中的參數表示一個生產者，就使用<? extends T>；如果它表示一個消費者，就使用<? super T>。

import java.util.Collection;
import java.util.Stack;

public class MyStack<E> extends Stack<E> {
    private static final long serialVersionUID = 1L;
    // 如果你想在方法中從input參數里獲取數據，使用<? extends T>通配符
    public void pushAll(Collection<? extends E> params) {
        for(E t : params) { push(t); }
    }
    // 如果你想在方法中把對象寫入一個input參數中，使用<? super T>通配符
    public void popAll(Collection<? super E> results) {
        while(!empty()) { results.add(pop()); }
    }
}

MyStack<Fruit> stack1 = new MyStack<Fruit>();
Collection<Apple> appleList = new ArrayList<>(Arrays.asList(new Apple("Apple1"), new Apple("Apple2")));
Collection<Orange> orangeList = new ArrayList<>(Arrays.asList(new Orange("Orange1"), new Orange("Orange2")));
Collection<Fruit> fruitList = new ArrayList<>(Arrays.asList(new Apple("Apple3"), new RedFushi("RedFushi3"), new Orange("Orange3")));
stack1.pushAll(appleList);
stack1.pushAll(orangeList);
stack1.pushAll(fruitList);
Collection<Fruit> resultList = new ArrayList<>();
stack1.popAll(resultList);
for (Fruit res : resultList) {
    System.out.print("[" + res.getName() + "--" + res.getClass().getSimpleName() + "] ");
    // [Orange3--Orange] [RedFushi3--RedFushi] [Apple3--Apple] [Orange2--Orange] [Orange1--Orange] [Apple2--Apple] [Apple1--Apple] 
}