Java——聊聊＜? extends T＞和＜? super T＞的含义及区别

Posted 2022-10-24 宋子浩

文章目录：

1.简介

2.上界通配符

3.下界通配符

4.简单小总结

---

1.简介

<? extends T> 和   <? super T> 是Java泛型中的“通配符（Wildcards）”和“边界（Bounds）”的概念。

• <? extends T>：是指 “上界通配符（Upper Bounds Wildcards）”
• <? super T>：是指 “下界通配符（Lower Bounds Wildcards）”

---

为什么要用通配符和边界？

使用泛型的过程中，经常出现一种很别扭的情况。比如我们有Fruit类，和它的派生类Apple类。

class Fruit 
class Apple extends Fruit 

然后有一个最简单的容器：Plate类。盘子里可以放一个泛型的“东西”。我们可以对这个东西做最简单的“放”和“取”的动作：set( )和get( )方法。

class Plate<T> 
    private T item;

    public Plate(T item) 
        this.item = item;
    

    public T getItem() 
        return item;
    

    public void setItem(T item) 
        this.item = item;
    

现在我定义一个“水果盘子”，逻辑上水果盘子当然可以装苹果。

Fruit fruit = new Apple(); //正确
Plate<Fruit> p = new Plate<Apple>(new Apple()); //报错了

但实际上Java编译器不允许这个操作。会报错，“装苹果的盘子”无法转换成“装水果的盘子”。

实际上，编译器脑袋里认定的逻辑是这样的：

• 苹果 IS-A 水果
• 装苹果的盘子 NOT-IS-A 装水果的盘子

所以，就算容器里装的东西之间有继承关系，但容器之间是没有继承关系的。所以我们不可以把Plate的引用传递给Plate。

为了让泛型用起来更舒服，Sun公司的那些大牛们就想出了 <? extends T> 和 <? super T> 的办法，来让”水果盘子“和”苹果盘子“之间发生关系。

---

2.<? extends T>上界通配符

下面代码就是“上界通配符（Upper Bounds Wildcards）”：

Plate<? extends Fruit>

翻译成人话就是：一个能放水果以及一切是水果派生类的盘子。再直白点就是：啥水果都能放的盘子。这和我们人类的逻辑就比较接近了。Plate<？ extends Fruit>和Plate<Apple>最大的区别就是：Plate<？ extends Fruit>是Plate<Fruit>以及Plate<Apple>的基类。直接的好处就是，我们可以用“苹果盘子”给“水果盘子”赋值了。

Plate<? extends Fruit> p = new Plate<Apple>(new Apple());

假设，我有下面这样的继承结构：↓↓↓ 

class Food 

class Fruit extends Food 
class Meat extends Food 

class Apple extends Fruit 
class Banana extends Fruit 
class Beef extends Meat 
class Pork extends Meat 

class RedApple extends Apple 
class GreenApple extends Apple 

此时，上面的 <? extends Fruit> 就表示下图的红色部分。

class MainTest1 
    public static void main(String[] args) 
        Plate<? extends Fruit> plate = new Plate<>(new Apple());
        //不能存入任何元素
//        plate.setItem(new Fruit());
//        plate.setItem(new Apple());

        //读取出来的东西只能存放在Fruit或它的基类里
        Fruit fruit = plate.getItem();
        Food food = plate.getItem();
        Object obj = plate.getItem();
        //Apple apple = plate.getItem(); //报错
    

但是呢，在上界通配符中存在着一定的缺陷：不能往里存，只能往外取。

<? extends Fruit>会使往盘子里放东西的set()方法失效。但取东西get( )方法还有效。比如下面例子里两个set()方法，插入Apple和Fruit都报错。

• setItem() : 编译器只知道元素类型是 Fruit 或 Fruit 的子类，所以有可能是 Fruit、Apple、Banana、RedApple、GreenApple中的某一个类型，那么当我们向其中添加元素时，编译器并不知道具体是哪一个 (派生) 类。所以这种操作是不允许的。
• getItem() : 即使编译器不知道此时类、集合中的元素是 Fruit、Apple、Banana、RedApple、GreenApple 中的哪一个，但是能够确定的是这些元素都是由 Fruit 派生出来的，所以上面的代码中 getItem 方法是可以用 Fruit、Fruit的父类Food、总类Object 接收。

---

3.<? super T>下界通配符

下面代码就是“下界通配符（Upper Bounds Wildcards）”：

Plate<? super Fruit>

表达的就是相反的概念：一个能放Fruit以及一切是Fruit基类的盘子。Plate<? super Fruit>是Plate<Fruit>的基类，但不是Plate<Apple>的基类。对应刚才那个例子，Plate<? super Fruit>覆盖下图中红色的区域。 

Plate<? super Fruit> plate = new Plate<>(new Fruit());

假设，我有下面这样的继承结构：↓↓↓ 

class Food 

class Fruit extends Food 
class Meat extends Food 

class Apple extends Fruit 
class Banana extends Fruit 
class Beef extends Meat 
class Pork extends Meat 

class RedApple extends Apple 
class GreenApple extends Apple 

此时，上面的 <? superFruit> 就表示下图的蓝色部分。

class MainTest2 
    public static void main(String[] args) 
        Plate<? super Fruit> plate = new Plate<>(new Fruit());
        //存入元素正常
        plate.setItem(new Fruit());
        plate.setItem(new Apple());
        //读取出来的东西只能存放在Object类中
        //Apple apple = plate.getItem();
        //Fruit fruit = plate.getItem();
        Object obj = plate.getItem();
    

但是呢，在下界通配符中存在着一定的缺陷：下界<? super T>可以往里存，但往外取只能放在Object对象里。

使用下界<? super Fruit>会使从盘子里取东西的get()方法部分失效，只能存放到Object对象里。set( )方法正常。

• setItem() : 编译器只知道元素类型是 Fruit 或者 Fruit 的基类或父类，所以有可能是 Fruit、Food、Object 其中的一个类型。编译器知道类型的下界是 Fruit ，根据类型向上兼容的特性，所以可以添加的元素是 Fruit 以及 Fruit 的派生类。
• getItem() : 既然编译器不确定集合类型是 Fruit 或者 Fruit 的基类或父类中的哪一种，可能是Fruit，可能是Food，那么返回类型只能是它们的共同父类 Object。但是这里可以通过强制类型转换成相应的Fruit的子类。

---

4.简单小总结

最后看一下什么是PECS（Producer Extends Consumer Super）原则，已经很好理解了：

• <? extends C> 适合大量做获取操作的情景。
• <? super C> 适合大量做添加操作的情景。

特点：<? extends C> 的 add() 被限制，<? super C> 的 get() 被限制。