Java 泛型（generics）是 JDK 5 中引入的一个新特性，泛型提供了编译时类型安全检测机制。
本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
java 中泛型标记符E - Element (在集合中使用，因为集合中存放的是元素)T - Type（Java 类）K - Key（键）V - Value（值）N - Number（数值类型）？ - 通配符，表示不确定的 java 类型
先来看看不使用泛型的例子：
public class GenericTest {public static void main(String[] args) {List list = new ArrayList();Cat cat = new Cat();Dog dog = new Dog();list.add(cat);list.add(dog);Iterator iterator = list.iterator();while (iterator.hasNext()) {// 通过Iterator取出的每一项都是object类型，下面语法是错误的// Animal a = iterator.next(); // Type mismatch: cannot convert from Object to// Animal// 需要向下转型，获取Animal类Animal a = (Animal) iterator.next();// 判断是Cat还是Dog类的实例并调用相应方法if (a instanceof Cat) {((Cat) a).catCall();} else {((Dog) a).dogCall();}}}}class Animal {public void call() {System.out.println("动物的叫声~");}}class Cat extends Animal {public void catCall() {System.out.println("喵喵喵~");}}class Dog extends Animal {public void dogCall() {System.out.println("汪汪汪~");}}
使用泛型后的代码：
public static void main(String[] args) {List list = new ArrayList();Cat cat = new Cat();Dog dog = new Dog();list.add(cat);list.add(dog);Iterator iterator = list.iterator();while (iterator.hasNext()) {Animal a = iterator.next();if (a instanceof Cat) {((Cat) a).catCall();} else {((Dog) a).dogCall();}}}
Tips：‘<>’钻石语法，自动检测类型。即这样写也可以 List list = new ArrayList<>();
（推荐）引用与具体实例的泛型是保持一致。
使用泛型List，表示此集合中就只能存放Animal类型的数据了，起到了统一集合中元素的数据类型的作用。如果试图存储非Animal类型（及其子类），程序会在编译期间报错。
有界的类型参数目的是限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends/super关键字，最后紧跟它的上界/下界。
上界：<? extends T> ，该list只能获取（get）元素，不能添加（add）元素下界：<? super T> ， 该list只能添加（add）元素，不能获取（get）元素
PECS原则
全称 Producter Extends, Consumer Super，即 供应者使用 Extends,消费者使用 Super。
示例代码中有如下继承关系，以便理解：
class Food { }class Fruit extends Food {}class Banana extends Fruit {}class Apple extends Fruit {}class RedApple extends Apple {}class Green extends Apple {}
没有泛型上下界的问题
泛型的上界通配符<? extends T>//Apple是Fruit的子类，语法正确Fruit apple = new Apple();//Type mismatch: cannot convert from ArrayList
显然ArrayList
List<? extends Fruit> apple2 = new ArrayList();
那么这个怎么来理解呢？在上面的例子中，？ extends Fruit代表任何继承了Fruit的子类（包含Fruit本身），都可以装进去（如下图）。
上界通配符的特点只能取，不能存！
怎么个说法呢？先说“只能取”，这个很好理解，集合中都是Fruit的子类，那么取出来的元素必然都能用Fruit来进行引用。
测试代码：
List appleList = new ArrayList<>(); List
“不能存”又该如何理解呢？往下慢慢看，你就知道了。
List appleList = new ArrayList<>(); appleList.add(new Apple()); List<? extends Fruit> plate1 = appleList; plate1.add(new Apple()); // 报错！
eclipse里报错信息，显示确实不让添加：
这就很奇怪了，list里全都是Fruit子类吗？那我们向list添加它的子类（Apple）为什么不行？
我们重新捋一捋，首先plate1引用的是appleList，而这个appleList中的泛型限定上界为Apple，那这也就意味着plate1的泛型也该是Apple，我们向其中添加Apple元素（RedApple和GreenApple）都没有问题，它们都能转为Apple类型（向上转型）。
回过头来看，虽说 <? extends Fruit>，它表示的是任何继承了Fruit的子类，没问题吧，照这么说添加Banana应该也可以啊，但是不行！别忘了，我们已经将plate的指向到了appList，而appleList规定了泛型是Apple。如果向其中添加Banana，它能转换成Apple吗？答案是否定的。
为了保证绝对安全，限制了上界不能进行添加元素，以免发生转型失败的问题。
附：一种同时能容纳Apple和Banana两种水果的盘子。
List<? extends Fruit> plate3 = Arrays.asList(new Apple(), new Banana()); Fruit apple = plate3.get(0); Fruit banana = plate3.get(1); System.out.printf("%s,%s", apple.getClass().getName(), banana.getClass().getName());
泛型的下界通配符<? super T>以? super Fruit为例，它代表的就是任何Fruit的父类及其Fruit本身（共同的祖先Object）。
下界通配符的特点“只能存，不能取”，其实倒也不是绝对不能取，只是为了区分上下界，让它们的特点完全相反，都把下界的特点都写成了不能取。在代码中实践是能取出来，只不过会使其中的元素类型失效，取出来的元素类型都是Object。
如下代码解释了“能存”：
// 定义了一个plate，下界为 <? super Apple> List<? super Apple> plate = new ArrayList<>(); plate.add(new Apple()); plate.add(new RedApple()); plate.add(new GreenApple());
以上代码能正常编译运行，那既然是Apple类型的任何父类，试着往其中添加Fruit，Food。
居然报错了？！
这不由得又绕回上面提到的“绝对安全”，会不会还出现上文中转型失败的情况？虽然说添加Apple，Fruit和Food类型都在下界范围内，但是谁能保证你就是添加的这几个类型的元素呢？比如上图我向其中添加Banana，它肯定会出问题的。
那为什么又让添加Apple及其子类呢，因为它绝对安全，它们都可以安全的转型成Apple类（向上转型），根本不会出啥毛病，所以是可以添加的。下界通配符“能存”元素就是这种体现。
附：什么叫“其实也能取”。
因为? super Apple这个范围太大了，无法准确知道你拿出来是具体什么类型，只能用最高的Object来进行引用，导致其中元素类型失效了。
参考：“界限”带来的灵活性 —— Java泛型的上下界