乐趣区

Java™ 教程(泛型的限制)

泛型的限制
要有效地使用 Java 泛型,必须考虑以下限制:

无法使用基元类型实例化泛型类型
无法创建类型参数的实例
无法声明类型为类型参数的静态字段
无法对参数化类型使用强制类型转换或 instanceof

无法创建参数化类型的数组
无法创建、捕获或抛出参数化类型的对象
无法重载将每个重载的形式参数类型擦除为相同原始类型的方法

无法使用基元类型实例化泛型类型
考虑以下参数化类型:
class Pair<K, V> {

private K key;
private V value;

public Pair(K key, V value) {
this.key = key;
this.value = value;
}

// …
}
创建 Pair 对象时,不能将基本类型替换为类型参数 K 或 V:
Pair<int, char> p = new Pair<>(8, ‘a’); // compile-time error
你只能将非基本类型替换为类型参数 K 和 V:
Pair<Integer, Character> p = new Pair<>(8, ‘a’);
请注意,Java 编译器将 8 自动装箱到 Integer.valueOf(8),将 ’a’ 自动装箱到 Character(‘a’):
Pair<Integer, Character> p = new Pair<>(Integer.valueOf(8), new Character(‘a’));
有关自动装箱的详细信息,请参阅自动装箱和拆箱。
无法创建类型参数的实例
你无法创建类型参数的实例,例如,以下代码导致编译时错误:
public static <E> void append(List<E> list) {
E elem = new E(); // compile-time error
list.add(elem);
}
作为解决方法,你可以通过反射创建类型参数的对象:
public static <E> void append(List<E> list, Class<E> cls) throws Exception {
E elem = cls.newInstance(); // OK
list.add(elem);
}
你可以按如下方式调用 append 方法:
List<String> ls = new ArrayList<>();
append(ls, String.class);
无法声明类型为类型参数的静态字段
类的静态字段是类的所有非静态对象共享的类级变量,因此,类型参数的静态字段是不允许的,考虑以下类:
public class MobileDevice<T> {
private static T os;

// …
}
如果允许类型参数的静态字段,则以下代码将混淆:
MobileDevice<Smartphone> phone = new MobileDevice<>();
MobileDevice<Pager> pager = new MobileDevice<>();
MobileDevice<TabletPC> pc = new MobileDevice<>();
因为静态字段 os 是由 phone、pager 和 pc 共享的,所以 os 的实际类型是什么?它不能同时是 Smartphone、Pager 和 TabletPC,因此,你无法创建类型参数的静态字段。
无法对参数化类型使用强制类型转换或 instanceof

因为 Java 编译器会擦除泛型代码中的所有类型参数,所以无法验证在运行时使用泛型类型的参数化类型:
public static <E> void rtti(List<E> list) {
if (list instanceof ArrayList<Integer>) {// compile-time error
// …
}
}
传递给 rtti 方法的参数化类型集是:
S = {ArrayList<Integer>, ArrayList<String> LinkedList<Character>, …}
运行时不跟踪类型参数,因此它无法区分 ArrayList<Integer> 和 ArrayList<String> 之间的区别,你可以做的最多是使用无界通配符来验证列表是否为 ArrayList:
public static void rtti(List<?> list) {
if (list instanceof ArrayList<?>) {// OK; instanceof requires a reifiable type
// …
}
}
通常,除非通过无界通配符对其进行参数化,否则无法强制转换为参数化类型,例如:
List<Integer> li = new ArrayList<>();
List<Number> ln = (List<Number>) li; // compile-time error
但是,在某些情况下,编译器知道类型参数始终有效并允许强制转换,例如:
List<String> l1 = …;
ArrayList<String> l2 = (ArrayList<String>)l1; // OK
无法创建参数化类型的数组
你无法创建参数化类型的数组,例如,以下代码无法编译:
List<Integer>[] arrayOfLists = new List<Integer>[2]; // compile-time error
以下代码说明了将不同类型插入到数组中时会发生什么:
Object[] strings = new String[2];
strings[0] = “hi”; // OK
strings[1] = 100; // An ArrayStoreException is thrown.
如果你使用泛型列表尝试相同的操作,则会出现问题:
Object[] stringLists = new List<String>[]; // compiler error, but pretend it’s allowed
stringLists[0] = new ArrayList<String>(); // OK
stringLists[1] = new ArrayList<Integer>(); // An ArrayStoreException should be thrown,
// but the runtime can’t detect it.
如果允许参数化列表数组,则前面的代码将无法抛出所需的 ArrayStoreException。
无法创建、捕获或抛出参数化类型的对象
泛型类不能直接或间接扩展 Throwable 类,例如,以下类将无法编译:
// Extends Throwable indirectly
class MathException<T> extends Exception {/* … */} // compile-time error

// Extends Throwable directly
class QueueFullException<T> extends Throwable {/* … */ // compile-time error
方法无法捕获类型参数的实例:
public static <T extends Exception, J> void execute(List<J> jobs) {
try {
for (J job : jobs)
// …
} catch (T e) {// compile-time error
// …
}
}
但是,你可以在 throws 子句中使用类型参数:
class Parser<T extends Exception> {
public void parse(File file) throws T {// OK
// …
}
}
无法重载将每个重载的形式参数类型擦除为相同原始类型的方法
一个类不能有两个在类型擦除后具有相同的签名的重载方法。
public class Example {
public void print(Set<String> strSet) {}
public void print(Set<Integer> intSet) {}
}
重载将共享相同的类文件表示,并将生成编译时错误。

上一篇:类型擦除

退出移动版