引言

前三节讲述了泛型常见声明及使用，泛型既可以在类上进行声明，也可以在单个方法上进行声明，并分别对这两种情况进行了总结。下面来学习下泛型扩展知识。

延用前面的Runnable接口、Buick类、Ford类、Driver类，新增加一个汽车容器类CarContainer

第一版

代码如下：

public interface Runnable {
    public void run();
}

public class Buick implements Runnable {
    
    @Override
    public void run(){
        System.out.println("buick run");
    }
    
    public void autoRun(){
        System.out.println("buick auto-run");
    }
}

public class Ford implements Runnable  {
    
    @Override
    public void run(){
        System.out.println("ford run");
    }
    
    public void fly(){
        System.out.println("ford fly");
    }
}

<pre name="code" class="java">public class Driver<T extends Runnable> {
    
    private T car;
    
    public void drive(T car){
        this.car = car;
        System.out.println("I am driving a " + car);
        car.run();
    }
    
    public T getDrivingCar(){
        return car;
    }
}

public class CarContainer<E extends Runnable> {
    private List<E> container = new ArrayList<E>();
    
    public void add(E e) {
        container.add(e);
    }
    
    public void add(Driver<E> producer) {
        container.add(producer.getDrivingCar());
    }
    
    public static void main(String[] args) {
        CarContainer<Runnable> container = new CarContainer<Runnable>();
        Buick buick = new Buick();
        container.add(buick);

        Driver<Runnable> driver = new Driver<Runnable>();
        driver.drive(buick);
        container.add(driver);
    }
}

前三个类不多说了，不明白的请参照前三节。说下CarContainer类， add方法接收泛型E类型对象，向容器中新增汽车。另一个重载add方法接收Driver<E>参数，获取到drivingCar并增加到容器中。

main静态方法中分别演示了这两个add的使用方法。先看第一个add方法使用，由于Buick类实现了Runnable接口的，container.add(buick)这样调用是没问题的；再看第二个add方法使用：首先driver.drive(buick)也没问题，原理同上；然后看container.add(driver)，由于container的元素类型为Runnable接口，而driver的元素类型也为Runnable接口，类型是完全匹配的，因此运行下程序也没问题，看上去都很美好。

假如有一个Driver<Buick>呢，请大家思考下这样调用看行不行

        Driver<Buick> driver = new Driver<Buick>();
        driver.drive(buick);
        container.add(driver);

The method add(Runnable) in the type CarContainer<Runnable> is not applicable for the arguments (Driver<Buick>)

从逻辑上说，这样调用应该是可以的，因为Buick实现了Runnable接口，但实际上不行。还好，有一种解决方法。JAVA提供了一种特殊化的参数类型，称作有限制的通配符类型(bounded wildcard type)，来处理类似的情况。我们的想法是第二个add方法接收的参数应该是“E的某个子类型的Driver”，可通过Driver<? extends E>实现。?代表任意未知类型，附加extends E限制，表示该未知类型必须是E的子类或其自身。修改后的代码如下：

第二版

    public void add(Driver<? extends E> producer) {
        container.add(producer.getDrivingCar());
    }

上面第一次出现跟泛型相关的通配符?，表示未知类型，下面简单说下其用法。

?

? 一般出现在方法参数上，代表未知类型。注意与泛型声明中的E区别。泛型E相当于一个类型占位符，可以在类中多处出现并意味着这几处将来的具体类型是一样的(例如Driver类和CarContainer中的泛型)；而?代表某个未知的具体类型，类多个地方出现的?没有任何关联。

?支持<? extends Parent>用法，代表未知类型必须是Parent的子类或自身，与泛型中的<E extends Parent>意义很相似。 

?还支持<? super Child>用法，代表未知类型必须是Child的超类或自身，这种用法在泛型中不存在(因为无意义)，请注意。

上面总结中提到<? super Child>用法，接下来补充学习下super的使用场景。

对于CarContainer类，跟add方法对应的，我们新增一个pop方法，如下：

    public void pop(Set<E> consumer){
        consumer.add(container.remove(container.size()));
    }

        CarContainer<Runnable> container = new CarContainer<Runnable>();
        Buick buick = new Buick();
        container.add(buick);
        
        Set<Runnable> consumer = new HashSet<Runnable>();
        container.pop(consumer);

The method pop(Set<Runnable>) in the type CarContainer<Runnable> is not applicable for the arguments (Set<Object>)

我们的想法是，pop接收的参数应用是"E的某种超类的Set"，通过?和super关键字配合使用正好可以达到这种目的，即Set<? super E>，修改后代码如下：

第三版

    public void pop(Set<? super E> consumer){
        consumer.add(container.remove(container.size()));
    }

通过?跟extends或super关键字在方法参数上的搭配使用，可以获得API最大限度的灵活性。

那么什么情况下该使用extends关键字，什么情况下该使用super关键字。有一个原则叫PECS，即producer-extends，consumer-super。

PECS意思是，如果带泛型参数化类型表示一个E生产者，就使用<? extends E>；如果它表示一个E消费者，就使用<? super E>。在上述示例中，add的producer参数产生E的实例供CarContainer使用，因此producer相应的类型为Driver<? extends E>；pop的consumer参数通过CarContainer消费E实例，因此consumer参数相应的类型为Set<? super E>。如果参数即是生产者又是消费者呢，那就不适合使用通配符?，因为你需要的是严格的类型匹配，即直接使用Set<E>

上面关于泛型的通配符?、extends和super的使用方法参照了《Effective.Java_2中文版.pdf》一书，由于水平有限，可能大家还没看明白。欢迎大家提问。

关于这讲实践演示，暂时在项目中没有用到，以后补充

结束语

关于泛型的学习和实践到此结束，总共四节，谢谢大家的关注。等有时间了，想再跟大家一起学习下设计模式，我觉得这也是每个Java程序员的必修课。敬请期待

java泛型学习和实践(4)