Java 中 <? super T> 与 <? extends T> 的区别

迷南。 2022-01-15 02:29 463阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

有很长一段时间没弄明白，Java 中 <? super T> 与 <? extends T> 的区别，看过网上很多大神的解释，个人能力有限，好多都看到很迷糊，其中有一篇很浅显易懂，所以记下来，分享一下：

<? extends T>是指：上界通配符（Upper Bounds Wildcards）

<? super T> 是指：下界通配符（Lower Bounds Wildcards）

##  ##

## <? extends T> 子类型限定 ##

**1. 概述:限定泛型只能为T类型的子类或者本身**

**2. 例子**

List<? extends Number> list2 = new ArrayList<Integer>();
    
     List<? extends Number> list2 = new ArrayList<Double>();
    
    List<? extends Number> list2 = new ArrayList<Number>();

**3. 操作局限性**

*  只能做获取的数据操作,在获取数据时,限定了是Number类的子类的泛型, 所以 获取的数据必定可以是Number类本身获取是其子类,但同时,由于子类有可能很多,不能直接获取到其子类对象.
 *  不能做添加的数据操作,在添加数据时,由于泛型是限定Number类的子类或者本身,无法确定当前列表里保存的是什么类型的数据。

## <? super T> 超类型限定 ##

**1. 概述:限定泛型只能为T类型的父类或者本身**

**2. 例子**

List<? super Integer> list1 = new ArrayList<Integer>();
    
    List<? super Integer> list1 = new ArrayList<Number>();
    
    List<? super Integer> list1 = new ArrayList<Object>();

**3. 操作局限性**

*  只能做添加数据的操作: 在添加数据的时候,通过限定的Integer 父类或者子类的子类型限定泛型,可以插入Integer对象
 *  不能做获取数据的操作: 在获取数据的时候,由于泛型的父类可能有很多种,读取时,不一定能够确定操作的数据是属于哪种类型,除非使用object所有类的基类来获取,由于泛型不确定性,这样会导致数据丢失.

## 适用领域 ##

**PESC原则**

*  “Producer Extends，Consumer Super”。如果参数化类型表示一个生产者，就使用<? extends T>；如果它表示一个消费者，就使用<? super T>
 *  生产者使用extends  
    如果你需要一个列表提供T类型的元素（即你想从列表中读取T类型的元素），你需要把这个列表声明成<? extends T>，比如List<? extends Integer>，因此你不能往该列表中添加任何元素。
 *  消费者使用super  
    如果需要一个列表使用T类型的元素（即你想把T类型的元素加入到列表中），你需要把这个列表声明成<? super T>，比如List<? super Integer>，因此你不能保证从中读取到的元素的类型。
 *  即是生产者，也是消费者  
    如果一个列表即要生产，又要消费，你不能使用泛型通配符声明列表，比如List<Integer>。

**简单点来说就是 使用时, 需要频繁的插入数据时, 就使用超类型限定, 需要获取数据时,就使用子类型限定**

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

## 源码例子 Collections.copy() ##

public static <T> void copy(List<? super T> destination, List<? extends T> source) {
        if (destination.size() < source.size()) {
            throw new IndexOutOfBoundsException("destination.size() < source.size(): " +
                    destination.size() + " < " + source.size());
        }
        Iterator<? extends T> srcIt = source.iterator();
        ListIterator<? super T> destIt = destination.listIterator();
        while (srcIt.hasNext()) {
            try {
                destIt.next();
            } catch (NoSuchElementException e) {
                // TODO: AssertionError?
                throw new IndexOutOfBoundsException("Source size " + source.size() +
                        " does not fit into destination");
            }
    
        // 体现点
        // ** srcIt.next()...
        // ** destIt.set()...
            destIt.set(srcIt.next());
        }
    }

原址： [http://www.jianshu.com/p/2005318f171f][http_www.jianshu.com_p_2005318f171f]

转载于:https://my.oschina.net/u/574036/blog/887454

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220114/819d3cbd4495413ab13d7c82d2dd3edf.png
[http_www.jianshu.com_p_2005318f171f]: http://www.jianshu.com/p/2005318f171f