Java中泛型通配符思考

通配符有在Java中有两种 extends , super 两个！

结合Scala中的逆变和协变的知识，我们可以理解，extends 的是一个协变的，super是逆变的！

1. 为什么List中， List<? extends A> 不能添加元素？

        // 现有继承结构如下：Base父类，A是Base的直接子类，B也是Base的直接子类！
        List<A> aList = new ArrayList<>();
        
        // 这个是合法的，协变的定义
        List<? extends Base> list = aList;
        
        // 非法操作，编译会出错的
        list.add(new B());

从代码的逻辑推理，不能编译时应该的，因为其实这里的 list是一个 List<A> 的对象，我们通过 list.add(new B()) 其实最终调用的是aList的add 但是 aList是一个泛型为A的List向其中插入B的对象，是不合理的！

但是此时我们，可以取出list的对象，并且我们知道这时候，list中的元素必然是Base的子类！所以我们可以使用Base和Base的父类去接 list的子类的元素，是安全的！

2. 为什么List中，List<? super A> 不能get元素？

        // 构造Base的List
        List<Base> baseList = new ArrayList<>();
        // 合理的，满足逆变的定义
        List<? super A> list = baseList;
        // 合法！此时只能添加A和A的子类！
        list.add(new A());
        
        // 不合法，此时GET 只能获取Object！
        A a = list.get(1);

为什么super通配符就可以add元素呢？
要注意的是，此时只能添加A和A的子类！此时list对象的泛型，表示这个List存储的是A和A的父类们！
所以此时添加A和A的子类，是不会导致原本List出问题的！我们向list添加元素，最终调用的是 baseList的add方法！我们可以向baseList中插入Base的和Base的子类，所以A和A的子类，自然是可以插入的！

为什么我们 get(0) 获得只能用 Object接呢？

因为我们说了 list 此时的泛型意思是，List能存储A和A的父类！由于A和A的父类，有很多，最通用的父类只有Object了，此时list不一定都是Base类的对象，因为Object也是A的父类！此时只能去拿最顶级的父类Object！我们通过下面的例子能更加的体现这种不安全的特性！

        List<Object> objList = new ArrayList<>();
        List<? super A> list = objList;
        list.add(new A());

我们使用 List<? super A> 接了一个 List<Object> 对象，这也是可以的，符合逆变的定义，但是此时我们get的是什么呢？只能是Object啊！

综上，由于逆变的特性，super中无法get到某个类型的元素是合理的！

Java中协变和逆变的使用的场景！

协变比较自然，如果我们的方法要接受一个List，这个List可以接受Base的所有子类的列表！这时候自然是要使用协变！因为我们 可以使用需要 List<A> 代替 List<Base> 。

逆变用的比较的少！方法的参数是应该是逆变的！

为什么方法的参数需要使用逆变呢？

    @Test
    public void test6() {

        Function<Object, String> obj2String = Object::toString;
        
        // 满足逆变的性质
        Function<? super Double, String> d2String = obj2String;
    }

    public void getValue(Function<? super Double, String> func) {
    }

这里有个 func 参数，它表示一个方法，我们为什么要它是逆变的呢？

现在我们需要的是一个 Double -> String 的方法，但是我们可传入 Double 的父类 -> String 的方法！因为 如果父类都有满足的方法了，那么子类必然是有这个方法的 ，所以这里的是安全的，这个在 Lambda中会体现的更加的明显，如果上面的getValue 不是 ? super Double 那么我们的 Object -> String 就无法传入！

那如果在方法上入参上使用 ? extends Base 呢 ？
这样写，不会产生编译时错误，但是方法将会无法调用！

        Function<A, String> a2Str = Object::toString;
        // 符合协变的特性
        Function<? extends Base, String> base2Str = a2Str;
        // 无法编译
        base2Str.apply(new Base());

但是 base2Str 方法没办法传递非 null 参数

其实在方法入参中使用 extends 是不正确的，当你看到一个函数类型是 Function<? extends Base, String> ，你不能确定 入参是 哪种具体的 Base 子类型！