●泛型是一个很令人费解的概念，但却是理解类型系统的重要基石！
大部分内容摘自《kotlin极简教程》，加上了自己的一些理解，写的不好，请多指教！
型变有三种基本的形态：协变（covariant）， 逆变(cotravariant)，不变(invariant)
我们先从java了解的类型通配符介绍这三个概念：java中通配符有一下两种形式：
▲？ extends T：子类型上界限定符，指定类型的上界（只能是T类型或者T的子类）
▲？ super T ：父类的下界限定符，指定类型的下界（只能是T类型或者是T类型的父类）
interface Animals{
void eat();
void run();
}
class Cat implements Animals{
@Override
public void eat() {}
@Override
public void run() { }
}
class Dog implements Animals{
@Override
public void eat() {}
@Override
public void run() {}
}在这里我先用java写几个类，在java中我们知道：Animal是Cat和Dog的父类，可以直接使用Cat的子类和Dog的
子类给Animals的一个对象赋值，那么ArrayList<Animals> animals = new ArrayList<Cat>()或者
ArrayList<Animals> animals = new ArrayList<Dog>()还可以吗？或者说ArrayList<Animals>还是
ArrayList<Cat>()或者ArrayList<Dog>的父类吗？
我们试试看：
可以看到编译报错，是不可能这样赋值的！
那么泛型通配符就派上用处了。将ArrayList<Animal> animals改成 ArrayList<? extends Animal> ：
也就是说ArrayList<Animals>并不是ArrayList<Cat>()和ArrayList<Dog>的父类，而ArrayList<？ extends Animals>才是！
●但是这里的ArrayList<？ extends Animals>并不能添加Animal及其子类对象的！
因为如果能的话就既能添加Cat对象又能添加Dog对象，java是不允许的！但是能add（null）
上述这种情况就叫做协变（即F是C的父类，f(F)是f(C)的父类）所以<? extends T>实现了泛型的协变！(f(F)类似于List<F>的形式)
●<? super T>实现了泛型的逆变！
逆变即（即F是C的父类，f(C)是f(F)的父类）
如果既不是逆变又不是协变，就是不变。
List<? super Number>，这里限制了List的内容只能是Number和Number父类。例如List<Object> 就是他的子类，而Object是所有类的父类，这就是逆变！看代码：
ArrayList<Number> numbers = new ArrayList<Object>（）报错！
ArrayList<? super Number> numbers = new ArrayList<Object>()编译通过！
在这个list中我们不能添加Number的任一父类对象，但能添加Number和其所有子类的对象！
●PECS（Producer-Extends， Consumer-Super）
那么我们什么时候使用extends，什么时候使用super呢！
《kotlin极简教程》书上用了一个stack API来举例说明：
public class Stack<E>{
public Stack(){}
public void push(E v){}
public E pop(){}
public boolean isEmpty(){}
}实现pushAll方法
public void pushAll(Iterable<E> src){
for(E e : src)
push(e)
}假设有一个实例化的stack<Number>，要将stack<Integer>和stack<Float>里的所有值添加进去，调用上面的方法会出现type mismatch错误应该写成下面这种形式。
public void pushAll(Iterable<？extends E> src){
for(E e : src)
push(e)
}
而要实现popAll方法，将一个stack中的元素依次取出add至dst中，不用通配符时：
public void popAll(Stack<E> dst) {
while(!isEmpty())
dst.push(pop())
}如果要将一个stack<Number>栈全部输出至一个stack<Object>中， 即dst是stack<Object>类，则一样会出现type mismatch错误，应将方法改成：
public void popAll(Stack<？ super E> dst) {
while(!isEmpty())
dst.push(pop())
}将其PECS称为Get and Put principle
在java.util.Collection的copy方法中完美地诠释了PECS：
public static <E> void copy(List<? super E> dest, List<? extends E> src) {
int srcSize = src.size();
if(srcSize > dest.size())
throw new IndexOutOfBoundsException("Source does not fit in dest");
...略
}大致可以这么解释，在这个方法中，我们从src中取数据，即src是producer，然后将数据添加至dest，所以dest是consumer所以，PECS，前者就是super，后者就是extends。
●kotlin：
java中有通配符，kotlin中则抛弃了这些，引用了生产者消费者概念，从上面的copy方法中也可以看出端倪。
kotlin把只负责安全读取数据的对象称为生产者，只负责安全写入数据的对象为消费者。kotlin中，生产者用
<out T>（等价于<? extends T>），消费者用<in T>（等价于<> super T>）。
写不下去了。。。