从泛型的使用情况看出你对语言的理解程度（1）

从JDK5开始，泛型就已经作为编译时类型安全监测机制加入进来。可是强哥发现，身边的很多开发人员，能够编写并熟练使用泛型的却非常少。一部分原因在于，开发人员对泛型的理解较浅，外加尽管我们在代码中不使用泛型，绝大部分代码还是可以很好的运行起来。这就导致了泛型的使用往往不尽如人意。

其实，对于泛型的熟练使用，能够极大的提升我们的编码正确率以及编码的可阅读性，其中的好处不言而喻。今天强哥就和大家聊聊一个泛型需要注意的点，认真看完，绝对有好处（之后还会推送几篇泛型相关的文章，这篇内容没理解好的话之后的推文可能不好理解哦）。

首先要熟悉泛型你就得懂得Java中：协变、逆变、不可变的关系。

假如有如下类：

class Food{} // 默认继承Objectclass Fruit extends Food{}class Meat extends Food {}class Apple extends Fruit{}class Beef extends Meat{}

Java中String类型是继承自Object的，姑且记做String ≦ Object，表示String是Object的子类型，String的对象可以赋给Object的对象。而Object的数组类型Object[]，理解成是由Object构造出来的一种新的类型,可以认为是一种构造类型，记f(Object)，那么可以这么来描述协变和逆变：

• 当A ≦ B时,如果有f(A) ≦ f(B),那么f叫做协变；
  
• 当A ≦ B时,如果有f(B) ≦ f(A),那么f叫做逆变；
  
• 如果上面两种关系都不成立则叫做不可变。
  

而我们的数组是协变的，下面的代码不会报错：

Food food = new Fruit();  Fruit [] arrFruit = new Fruit[3];Food [] arrFood = arrFruit; // 数组协变的

Java的泛型是不可变的：

List<Beef> beefList = new ArrayList<>();List<Food> foodList = beefList; //错误：不可协变  beefList = foodList; // 错误 ： 不可逆变
addFood(beefList);// 错误：：不可协变  
public void addFood(List<Food> foods){    foods.add(new Apple());}

为什么不能把beefList 作为参数传递给addFood(List<Food> list)方法呢？这儿我们用反正法类证明：

1. addFood 方法接收List<Food> list的类型参数，那么在addFodd 方法体中能给传递进来的 foods 添加任何Food 的子类型（这一点是玩完全合法的）。然后我们假设 addFood(beefList)这行代码没有问题，也就意味着能通过addFood 方法给beefList 里面增加任何Food 的子类型（比如：list.add(new Apple())）.
   
2. 通过第一步，我们给 装肉的beefList 里面加了一个苹果（Apple）, 那么从beefList get 数据赋值给Beef 的时候（Beef beef = beefList.get(0)）就会发生类型转换异常 ，因为取出来的是一个Apple ，这样明显有问题了。
   

因此：得出java中泛型是不变得，既不能协变，也不能逆变。

JAVA中泛型是不变的，可有时需要实现逆变与协变，怎么办呢？这时就需要通配符?。

<? extends E>实现了泛型的协变，比如：

List<? extends Food> foodList = new ArrayList<>();List<Apple> appleList = new ArrayList<>();foodList = appleList; // ok 协变
foodList.add(new Beef()); // 错误 不能执行添加null 以外的操作foodList.add(new Food());// 错误，同上，foodlist.add(new Apple()); // 错误，同上
Food food = foodList.get(index); //ok, 把子类引用赋值给父类显然是可以的

<？ extends Food>指明了上界，即表示了集合中存放的对象是 Food 或者Food 的子类，因此foodList 就表示了一个存放 Food 或者Food 的子类的集合，appleList 集合就是一个存放 Food 的子类 Apple 的集合， 因此可以把 appleList 赋值给 foodList ,但是不能对foodList 添加除null 以外的任何对象。为什么不能添加呢？其实很简单，如果可以允许的话，那么foodList 就可以添加Food 或者Food 的子类型，那么上面代码中在foodList = appleList;  赋值后，执行foodList.add(new Beef()); 操作就会导致给 appleList 里面添加了一个Beef 对象，显然这样是不对的。

因此可以得出结论：<? extends E>实现了泛型的协变。

<? super E>实现了泛型的逆变，比如：

List<? super Fruit> fruitList = new ArrayList<>();List<Food> foodList = new ArrayList<>();fruitList = foodList; // ok 逆变
foodList.add(new Meat()); 
fruitList.add(new Apple()); // ok，只能添加 Fruit 或者 其子类fruitList.add(new Food());// error, 只能添加 Fruit 或者 其子类
Fruit fruit = fruitList.get(0); // error，get出来的元素是Object类型Object obj = fruitList.get(0)；// ok

<? super Fruit> 指明了下界，即表示了集合中存放的对象只能是 Fruit 或者其父类，因此 fruitList 表示了一个存放 Fruit 或者其父类的集合，那么就可以把一个Fruit 父类Food的集合foodList 赋值给 fruitList (即：fruitlist = foodList)，这儿可能有的人就有点疑问了 <? super Fruit> 指明了集合存放的对象是 Fruit 或者其父类,那为什么往集合中添加 Fruit  的父类元素不行呢（fruitList.add(new Food())）？

同样我们用反正法来说明，假如可以向<? super E> 集合中添加 E 的父类，那么就可以向 fruitList 添加 Fruit 的父类（Food or Object)，在本例中，我们把 foodList 赋值给了 fruitList(fruitList = foodList)，既然可以添加父元素，那么我们执行 fruitList.add(new Food)就相当于给 foodList 集合里面添加了一个 Food 元素，这看起来没有什么问题，因为foodList 本来就是用来装 Food 元素的，但是如果我们添加的 Fruit 父类是Object 对象（或者一个 Fruit 实现的和 Food 无关的接口，又或者 Food  继承的一个其他类 B,那么 B 也是 Fruit 的父类），那么就意味着给 foodList 里面添加了和 Food 无关的类，这样显然是不行的。那么为什么往 fruitList 里面添加 Fruit 或者其子类元素是可以的，因为 fruitList 表示的就是一个存放 Fruit 或者其父类的集合，所以这个集合肯定就能装Fruit 或者其子类，比如上面把 foodList 赋值给 fruitList 后，往fruitList 里面添加 Apple 就相当于往 foodList 里面添加 Apple ,显然是可以的，对于 get 操作时为什么读取出来的是 Object ，是因为 fruitList  集合表示的存放 Fruit 或者其父类的集合，而 Fruit 的父类可能有很多，在本例中由于我们知道存的是 Food（fruitList = foodList）, 但是在实际中，谁知道在运行时到底存的是哪一个呢？因此为了安全全部定义为 Object  类型。

因此得出结论：<? super E>实现了泛型的逆变。