Java 中的泛型

一、泛型的意义

泛型，又叫 显式参数多态，在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