一、泛型的意义
泛型，又叫 显式参数多态，在c++里又叫模板。在强类型的编程语言中普遍作用是：
1. 可以显式地使用参数注入，实现代码复用（避免粗暴地使用 Object)
2. 加强编译时的类型安全（类型检查）
3. 减少类型转换的次数
二、Java 中的 泛型
编译时进行类型擦除生成与泛型类同名的原始类，但类型参数都被删去了。类型变量由类型限界代替（通常为 Object）。
三、集合协变与泛型上下界
Java 中泛型集合不具有协变性，无法利用多态替换参数。需要使用通配符，用于接收某些类型。 (PS: Java 中矩阵或者数组具有协变性，因此数组参数具有多态性。)
public static double totalArea(Collection<? extends Shape> arr)
四、泛型擦除
问题1: 什么时候需要避免泛型擦除？
使用泛型，程序在编译时，类型会完全擦除或保留部分（如果定义了上下限）。
涉及到具体类型的操作时会自动加上强制转换。比如：
public static void main(String[] args) {
List<Integer> m = new ArrayList<>();
m.add(3);
System.out.println(m.get(0) + 5);
}
编辑器会替换为：
public static void main(String[] args) {
List m = new ArrayList();
m.add(3);
System.out.println((Integer)m.get(0) + 5);
}
类型擦除还会造成以下编译时错误：
错误 ① “Erasure of method xyz(…) is the same as another method in type Abc”
public class App {
public int process(List<Person> people) {
for (Person person : people) {
log.info("Processing person: " + person.toString());
}
return person.size();
}
public int process(List<Employee> employees) {
for (Employee employee : employees) {
log.info("Processing employee: " + employee.toString());
}
return employees.size();
}
}
以上代码由于类型擦除，会被编译成：
public class App {
public int process(List people) {
for (Person person : people) {
log.info("Processing person: " + person.toString());
}
return person.size();
}
public int process(List employees) {
for (Employee employee : employees) {
log.info("Processing employee: " + employee.toString());
}
return employees.size();
}
}
那么存在的错误显而易见。两个具有相同签名 ( process(List) ) 的方法无法在同一个类*存，简单的解决方法是修改某一个方法的签名。
错误 ② “The method xyz(Foo) in the type Abc is not applicable for the arguments (Foo)”
public class App {
public int processPeople(List<Person> people){
for (Person person : people) {
log.info("Processing person: " + person.toString());
}
return person.size();
}
..
}
..
List<Employee>employees;
employees = new ArrayList<>();
employees.add(employee1);
employees.add(employee2);
App app = new App();
// ERROR ON NEXT LINE!
app.processPeople(employees);..
这个错误的原因是泛型集合不具有协变性。无法强制转换。
类型擦除有时还会影响序列化性能（因为不知道类型信息，从而无法针对性地选择序列化方式，因此影响了序列化的性能）。
问题2: 如何避免泛型擦除？
第一，使用泛型边界。可以有限地保留类型信息。如：
LinkedList<? extends Building>，LInkedList<? super House>
分别设置了上界和下界。在这种情况下编译器不会将泛型信息完全擦除，比如上述两个List经过编译后分别编程了LinkedList<Building> 和 LinkedList<House>。
第二，借助类型推断隐式确定具体参数类型，常用于函数式编程类型推断（需要编程语言支持）。
第三，不直接使用泛型。比如定义一个新的类型，继承或实现原泛型类或接口，并且注入具体的参数类型，则不会发生类型擦除。如:
env.fromElements(1, 2, 3)
.map(i -> new DoubleTuple(i, i))
.print(); public static class DoubleTuple extends Tuple2<Integer, Integer> {
public DoubleTuple(int f0, int f1) {
this.f0 = f0;
this.f1 = f1;
}
}
参考
https://www.ibm.com/developerworks/cn/java/java-language-type-erasure/index.html