(十四)、泛型中extends和super的区别

extends 

泛型中extends的主要作用是设定类型通配符的上限

要理解这句话，我们先从一个例子来看

class Fruit{
    public void call(){
        System.out.println("这是一个水果");
    }
}

class Banana extends Fruit{
    @Override
    public void call(){
        System.out.println("这是一个香蕉");
    }
}

class Apple extends Fruit{
    @Override
    public void call(){
        System.out.println("这是一个苹果");
    }
}

public class Test{
    public void test1(List<Fruit> fruits){
        for (Fruit fruit: fruits){
            fruit.call();
        }
    }
    public static void main(String[] args) {
        List<Apple> apples = new ArrayList<>();
        List<Fruit> fruits = apples;    //类型转换失败
        Test test = new Test();
        test.test1(fruits);     //失败
    }
}

我们使用Apple继承了Fruit类，然后建立了两个list，一个容纳的是apple，一个容纳的是fruit。

按照常理来说，因为Apple继承了Fruit，List<Apple>应该也是List<Fruit>的子类型。但是实际上不是这样的，运行上述程序，会报一个如下所示的错误。

Error:(42, 20) java: 不兼容的类型: java.util.List<com.company.Apple>无法转换为java.util.List<com.company.Fruit>

 

我们可以这样理解，如果上述代码能够正常运行，那把call方法修改成添加一个Banana对象会怎么样，因为test1方法中实际上使用的是List<Apple>，是不能够添加到Banana的，就会出错。所以List<Apple>不是List<Fruit>的子类型。

那我们如何处理类似的情况呢，这就需要使用extends了。

public class Test{
    public void test1(List<? extends Fruit> fruits){
        for (Fruit fruit: fruits){
            fruit.call();
        }
    }
    public static void main(String[] args) {
        List<Apple> apples = new ArrayList<>();
        Test test = new Test();
        test.test1(fruits);     //失败
    }
}

 

<? extends Fruit>代表的是上界通配符，也就是说这个List中存放的对象都是Fruit以及其子类的对象，这样我们就不用因为输入的List中类型的不同而改变代码了。

上界通配符有一个特点，就是程序只知道List<? extends Fruit>中的对象是Fruit的子类的对象，但是如果Fruit的子类有很多个，那个在使用add方法的时候，就可能出现本来是List<Apple>，然后在其中添加了banana对象，从而失败。

 

super

super与extends是完全相反的，其定义的是下界通配符。

List<? super Fruit>也就是说List中存放的都是Fruit和它的父类的对象，比如food，Object。

而且如果要在这个List中取出数据，那就不能够确定具体是Fruit的哪个父类的对象，可能是Food，可能是Object。为了保证一定能够取出来，就必须把其转型成Object对象，但是这个时候就会失去原有对象的类型信息。所以List<? super Fruit>不能够提取数据。

 

上下界通配符的副作用

边界让Java不同泛型之间的转换更容易了。但不要忘记，这样的转换也有一定的副作用。那就是容器的部分功能可能失效。

上界<? extends T>不能往里存，只能往外取

原因是编译器只知道容器内是Fruit或者它的派生类，但具体是什么类型不知道。可能是Fruit？可能是Apple？也可能是Banana，RedApple，GreenApple？

 

下界<? super T>不影响往里存，但往外取只能放在Object对象里

因为下界规定了元素的最小粒度的下限，实际上是放松了容器元素的类型控制。既然元素是Fruit的基类，那往里存粒度比Fruit小的都可以。但往外读取元素就费劲了，只有所有类的基类Object对象才能装下。但这样的话，元素的类型信息就全部丢失。