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

上一篇:Photon + Unity3D 线上游戏开发 学习笔记(一)


下一篇:[游戏开发-学习笔记]菜鸟慢慢飞(九)- NGUI- UIPanel(官方说明翻译)