【java】泛型介绍
概念
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
有界的类型参数
目的是限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends/super关键字，最后紧跟它的上界/下界。
- 上界： ，该list只能获取（get）元素，不能添加（add）元素
- 下界： ， 该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 {}没有泛型上下界的问题
泛型的上界通配符
// Apple是Fruit的子类，语法正确
Fruit apple = new Apple();
// Type mismatch: cannot convert from ArrayList to List
List apple2 = new ArrayList(); // 编译报错 显然ArrayList? extends Fruit，就能解决问题。
List apple2 = new ArrayList(); 那么这个怎么来理解呢？在上面的例子中，？ extends Fruit代表任何继承了Fruit的子类（包含Fruit本身），都可以装进去（如下图）。
上界通配符的特点
只能取，不能存！
怎么个说法呢？先说“只能取”，这个很好理解，集合中都是Fruit的子类，那么取出来的元素必然都能用Fruit来进行引用。
测试代码：
List appleList = new ArrayList<>();
List bananaList = new ArrayList<>();
appleList.add(new Apple());
bananaList.add(new Banana());
List plate1 = appleList;
Fruit f1 = plate1.get(0);
List plate2 = bananaList;
Fruit f2 = plate2.get(0);
// com.camphor.Apple,com.camphor.Banana
System.out.printf("%s,%s", f1.getClass().getName(), f2.getClass().getName()); “不能存”又该如何理解呢？往下慢慢看，你就知道了。
List appleList = new ArrayList<>();
appleList.add(new Apple());
List 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 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 Fruit为例，它代表的就是任何Fruit的父类及其Fruit本身（共同的祖先Object）。
下界通配符的特点
“只能存，不能取”，其实倒也不是绝对不能取，只是为了区分上下界，让它们的特点完全相反，都把下界的特点都写成了不能取。在代码中实践是能取出来，只不过会使其中的元素类型失效，取出来的元素类型都是Object。
如下代码解释了“能存”：
// 定义了一个plate，下界为
List 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泛型的上下界