引言
前三节讲述了泛型常见声明及使用,泛型既可以在类上进行声明,也可以在单个方法上进行声明,并分别对这两种情况进行了总结。下面来学习下泛型扩展知识。
延用前面的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()));
}
接收集合类consumer参数,方法体中从container中移除最后一个元素并加入到consumer中。使用示例如下:
CarContainer<Runnable> container = new CarContainer<Runnable>();
Buick buick = new Buick();
container.add(buick);
Set<Runnable> consumer = new HashSet<Runnable>();
container.pop(consumer);
假如你有另一个Set<Object> consumer = new HashSet<Object>()呢,如果按照上面调用,会出现编译错误:
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()));
}
修改后,支持了Set<Object> consumer调用方式。
通过?跟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程序员的必修课。敬请期待
版权声明:本文为博主原创文章,未经博主允许不得转载。