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] 
}