对泛型的限制

无法使用基本类型实例化泛型类型

考虑以下参数化类型：

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’)：

无法创建类型参数的实例

您无法创建类型参数的实例。例如，以下代码会导致编译时错误：

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 被Smartphone、Pager和TabletPC共享，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>[2];  // 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) { }
}

所有重载方法将共享相同的类文件表示形式，并会在编译时引发错误。