Java中 ? extends T 和 ? super T 如何理解？

╰+哭是因爲堅強的太久メ 2024-03-27 13:40 62阅读 0赞

## Java中 ? extends T 和 ? super T 如何理解？ ##

`转自博客：` [Java中 ? extends T 和 ? super T 的理解][Java_ _ extends T _ _ super T]

--------------------

#### 文章目录 ####

*  Java中 ? extends T 和 ? super T 如何理解？
 *   *  ? 通配符类型
     *  上界<? extends T>不能往里存，只能往外取
     *  下界<? super T>不影响往里存，但往外取只能放在Object对象里
     *  PECS原则
     *  总结

--------------------

### ? 通配符类型 ###

*  <? extends T> 表示类型的上界，表示参数化类型的可能是T 或是 T的子类;
 *  <? super T> 表示类型下界（Java Core中叫超类型限定），表示参数化类型是此类型的超类型（父类型），直至Object;

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

比如，我们现在定义：`List<? extends T>`首先你很容易误解它为继承于T的所有类的集合，你可能认为，你定义的这个List可以用来put任何T的子类，那么我们看下面的代码：  
这个代码的作用是什么呢？看了些博客后，我们来浅谈一下this与that的区别。

import java.util.LinkedList;
    import java.util.List;
    
    public class test {
        
        public static void main(String[] args) {
        
            List<? extends Father> list = new LinkedList<>();
            list.add(new Son());
        }
    }
    class Human{
        
    }
    class Father extends Human{
        
    }
    class Son extends Father{
        
    }
    class LeiFeng extends Father {
        
    }

**list.add(new Son());这行会报错：The method put(Son) is undefined for the type List<capture\#1-of ? extends Father>**

List<? extends Father> 表示 “具有任何从Son继承类型的列表”，编译器无法确定List所持有的类型，所以无法安全的向其中添加对象。可以添加null,因为null 可以表示任何类型。所以List 的add 方法不能添加任何有意义的元素，但是可以接受现有的子类型List 赋值。

你也许试图这样做：

List<? extends Father> list = new LinkedList<Son>();
    list.add(new Son());

**即使你指明了为Son类型，也不能用add方法添加一个Son对象。**

**list中为什么不能加入Father类和Father类的子类呢，我们来分析下。**

**`List<? extends Father>`表示上限是Father,下面这样的赋值都是合法的**

List<? extends Father> list1 = new ArrayList<Father>();
       List<? extends Father> list2 = new ArrayList<Son>();
       List<? extends Father> list3 = new ArrayList<LeiFeng>();

**如果List<? extends Father>支持add方法的话：**

*  list1可以add Father和所有Father的子类；
 *  list2可以add Son和所有Son的子类；
 *  list3可以add LeiFeng和所有LeiFeng的子类。

**下面代码是编译不通过的：**

list1.add(new Father());//error
    list1.add(new Son());//error

原因是编译器只知道容器内是Father或者它的派生类，但具体是什么类型不知道。可能是Father？可能是Son？也可能是LeiFeng，XiaoMing？编译器在看到后面用Father赋值以后，集合里并没有限定参数类型是“Father“。而是标上一个占位符：CAP\#1，来表示捕获一个Father或Father的子类，具体是什么类不知道，代号CAP\#1。然后无论是想往里插入Son或者LeiFeng或者Father编译器都不知道能不能和这个CAP\#1匹配，所以就都不允许。

所以通配符`<?>`和类型参数的区别就在于，对编译器来说所有的T都代表同一种类型。比如下面这个泛型方法里，三个T都指代同一个类型，要么都是String，要么都是Integer。

public <T> List<T> fill(T... t);

但通配符`<?>`没有这种约束，`List<?>`单纯的就表示：集合里放了一个东西，是什么我不知道。

所以这里的错误就在这里，`List<? extends Father>`里什么都放不进去。

`List<? extends Father>` list不能进行add，但是，这种形式还是很有用的，虽然不能使用add方法，但是可以在初始化的时候一个Season指定不同的类型。比如：

List<? extends Father> list1 = getFatherList();//getFatherList方法会返回一个Father的子类的list

另外，由于我们已经保证了List中保存的是Father类或者他的某一个子类，所以，可以用get方法直接获得值：

List<? extends Father> list1 = new ArrayList<>();
    Father father = list1.get(0);//读取出来的东西只能存放在Father或它的基类里。
    Object object = list1.get(0);//读取出来的东西只能存放在Father或它的基类里。
    Human human = list1.get(0);//读取出来的东西只能存放在Father或它的基类里。
    Son son = (Son)list1.get(0);

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

> 下界用super进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至Object。

//super只能添加Father和Father的子类，不能添加Father的父类,读取出来的东西只能存放在Object类里
    List<? super Father> list = new ArrayList<>();
    list.add(new Father());
    list.add(new Human());//compile error 
    list.add(new Son());
    Father person1 = list.get(0);//compile error 
    Son son = list.get(0);//compile error 
    Object object1 = list.get(0);

因为下界规定了元素的最小粒度的下限，实际上是放松了容器元素的类型控制。既然元素是Father的基类，那往里存粒度比Father小的都可以。出于对类型安全的考虑，我们可以加入Father对象或者其任何子类（如Son）对象，但由于编译器并不知道List的内容究竟是Father的哪个超类，因此不允许加入特定的任何超类（如Human）。而当我们读取的时候，编译器在不知道是什么类型的情况下只能返回Object对象，因为Object是任何Java类的最终祖先类。但这样的话，元素的类型信息就全部丢失了。

### PECS原则 ###

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

*  频繁往外读取内容的，适合用上界Extends。
 *  经常往里插入的，适合用下界Super。

### 总结 ###

*  extends 可用于返回类型限定，不能用于参数类型限定（换句话说：? extends xxx 只能用于方法返回类型限定，jdk能够确定此类的最小继承边界为xxx，只要是这个类的父类都能接收，但是传入参数无法确定具体类型，只能接受null的传入）。
 *  super 可用于参数类型限定，不能用于返回类型限定（换句话说：? supper xxx 只能用于方法传参，因为jdk能够确定传入为xxx的子类，返回只能用Object类接收）。
 *  ? 既不能用于方法参数传入，也不能用于方法返回。

> **带有super超类型限定的通配符可以向泛型对象中写入，带有extends子类型限定的通配符可以向泛型对象读取。**

[Java_ _ extends T _ _ super T]: https://blog.csdn.net/jdsjlzx/article/details/70479227?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167565306016800182141674%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=167565306016800182141674&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v1~rank_v31_ecpm-3-70479227-null-null.142%5Ev73%5Einsert_down4,201%5Ev4%5Eadd_ask,239%5Ev1%5Econtrol&utm_term=java%E4%B8%AD%E7%9A%84%EF%BC%9F%E7%B1%BB%E5%9E%8B&spm=1018.2226.3001.4187