泛型通配符<? extends T>和<? super T>

 java使用了泛型来保证数据的安全性，避免了什么乱七八糟的

东西都往容器里扔的情况。一般情况下我们使用<T>来定义泛型，

例如下面这块代码

public <T> T[] toArray(T[] a)

但是有时我们也会使用<? extends T>和<? super T>，这里简单介绍下

<? extends T>被称为 上界通配符，意为可以存入的类型包括T以及T的子类，例如

    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

<? super T> 被称为下界通配符，意为可以存入的类型包括T以及T的父类，例如

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

也有同时使用的情况

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

验证代码如下，我们发现无法将<? extends Father>与GrandFather关联，

同样的，无法将<? super Father>与Child关联

public class PorblemSolution {
    
    public static void main(String[] args){

        Person<Father> p1 = new Person<Father>();
        
        Person<? extends Father> p2 = new Person<Child>(new Child());
        Person<? extends Father> p3 = new Person<Father>(new Father());
        // Person<? extends Father> p4 = new Person<GrandFather>(new GrandFather());
        // Type mismatch: cannot convert from Person<GrandFather> to Person<? extends Father>
        
        Person<? super Father> p5 = new Person<Father>(new Father());
        Person<? super Father> p6 = new Person<GrandFather>(new GrandFather());  
        // Person<? super Father> p7 = new Person<Child>(new Child());
        // Type mismatch: cannot convert from Person<Child> to Person<? super Father>
        
    }
}

    
class GrandFather{
    GrandFather(){};
}

class Father extends GrandFather{
    Father(){};
}

class Child extends Father{
    Child(){};
}

class Person<T> {
    
    private T item;
    
    Person(){};
    
    Person(T t){
        item = t;
    }
    
    public void set(T t){
        item=t;
    }
    
    public T get(){
        return item;
    }
}

<? extends T>和<? super T>为我们使用泛型提供了更多的实现方案，使得泛型的匹配不只局限于T本身。

但是，这两个通配符在使用过程中会泛型中类异常的风险增加，这里可以套用父类子类强制类型转换的思路去理解。

更详细的解释可以看这里https://www.zhihu.com/question/20400700

另外，我们需要知道java中的泛型是伪泛型，是加在编译层面的校验机制，在运行时是没有泛型这个东西的

有兴趣的可以了解下泛型擦除这个机制，这里还是给个样例

Person<Father> p1 = new Person<Father>();        
Person<? extends Father> p2 = new Person<Child>(new Child());    
System.out.println(p1.getClass());  // class JavaTest.Person
System.out.println(p2.getClass());  // class JavaTest.Person
System.out.println(p1.getClass() == p2.getClass()); // true