文章目录

说明
泛型的限制
泛型的继承规则
总结

说明

在这篇文章中，将讨论在java中使用泛型时需要考虑的一些限制。大部分限制都是由类型擦除引起的。

泛型的限制

不能使用基本类型实例化参数

不能用基本类型代替类型参数。因此，没有<double>，只有<Object>。当然，其原因就在于类型擦除。擦除之后，类含有Object类型的字段，而Object不能存储double值。

这的确令人烦恼。但是，这样做与Java语言中基本类型的独立状态相一致。这并不是个致命的缺陷，java只有8种基本类型，而且即使不能接受包装器类型（wrapper type)，也可以使用单独的类和方法来处理。

        List<double> list; // ERROR
        List<Double> doubleList; // OK

运行时类型查询只适用于原始类型

我们都知道，在java中可以使用 instanceof来检查某个类是否类型相同或者为其子类。

        String s = "x";
        if (s instanceof Object) {
            System.out.println(s);
        }

但是不能够使用instanceof操作泛型。
泛型类

		public class MyTool<T> {
		
		}

测试代码

        MyTool<String> myTool = new MyTool<>();
        if (myTool instanceof MyTool<String>){ // ERROR
            
        }
        if (myTool instanceof MyTool){ // Ok, Always True

        }

原因就是类型擦除，MyTool不同的泛型对象返回的class总是相同的，所有的MyTool对象的getClass都是调用的MyTool.class

        MyTool<Number> oMyTool = new MyTool<>();
        MyTool<Integer> sMyTool = new MyTool<>();
        // Always True
        System.out.println(oMyTool.getClass() == sMyTool.getClass());

不能创建参数化类型数组

    public static void main(String[] args) {
        MyTool[] myTools = new MyTool[3]; // OK
        MyTool<String>[] myTools1; // OK 声明泛型数组没有问题

        // ERROR 不能创建泛型数组
        MyTool<String>[] myTools2 = new MyTool<String>[3];
    }

如果一定要创建那么可以使用强制类型转换

        MyTool[] myTools = new MyTool[3];
        MyTool<Integer>[] myTools3 = (MyTool<Integer>[]) myTools;

这样写IDEA会报一个警告

这样写也是不安全的

        MyTool[] myTools = new MyTool[3];
        // myTools3执向myTools
        MyTool<Integer>[] myTools3 = (MyTool<Integer>[]) myTools;
        // 没有进行参数检查
        myTools[0] = new MyTool<File>();

编译器并不会对参数进行检查

Varargs警告

在上面，我们说了java不支持泛型类型的数组，但是，请看下面的代码

    public static void main(String[] args) {
        List<MyTool<String>> list = new ArrayList<>();
        MyTool<String> stringMyTool1 = new MyTool<>();
        MyTool<String> stringMyTool2 = new MyTool<>();
        addAll(list, stringMyTool1, stringMyTool2);
    }

    public static <T> void addAll(List<T> list, T... ts) {
        for (T t : ts) {
            list.add(t);
        }
    }

发现了什么？为了满足list的约束，ts不就必须是MyTool<String>的数组吗？这就和前面相违背了。对于这种情况，规则有所放松，只会得到一个警告，而不是错误

我们可以使用@SafeVarargs表示在addAll方法上来忽略警告
注意：@SafeVarargs只能用于static，final方法

不能实例化类型变量

    public <T> void test(T t) {
        T newT = new T(); // ERROR
    }

对于类型变量，我们不能够使用new，上面代码IDEA会提示如下

表示不能实例化T。原因也很简单嘛，T被类型擦除后就变成Object了，new Object()有什么意义呢？

不能构造泛型数组

前面说了类型变量不能实例化，自然而然的也就不能够实例化泛型数组了

    public <T> void test(T t) {
        T[] ts1; // 声明OK
        T[] ts2 = new T[3]; // 实例化ERROR
    }

泛型类的静态上下文中类型变量无效

public class Tool<T> {

    public static T t; //ERROR

    public static T getT() { //ERROR
        return t;
    }
}

这个很好理解，静态方法和静态字段是属于类的，当然无法得到泛型类的类型。

不能抛出或捕获泛型类的实例

既不能抛出也不能捕获泛型类的对象。实际上，泛型类根本就不能继承Throwable。

public class Test8<T> extends Throwable{ // ERROR
    
}

我们也不能使用泛型来进行catch

    public static <T extends Throwable> void test(T t) {
        try {
            int a = 1 / 0;
        } catch (T t1) {

        }
    }

可以取消对检查型异常的检查

这个感觉没啥用，其实就是通过@SuppressWarnings、类型擦除和泛型类来哄骗编译器，我们抛出应该泛型的异常，让编译器认为这不是应该检查型异常

    @SuppressWarnings("unchecked")
    public static <T extends Throwable> void throwAs(Throwable t) throws T {
        throw (T) t;
    }

上面代码就是，我们传入的可能是应该检查型异常，但是抛出的确实非检查型异常，这样就可以骗过编译器。

关于擦除后的冲突

泛型规范说明还引用了另外一个原则：“为了支持擦除转换，我们要施加一个限制：倘若两个接口类型是同一接口的不同参数化，一个类或类型变量就不能同时作为这两个接口类型的子类。”例如，下述代码是非法的：

class Employee implements Comparable<Employee>{…}
class Manager extends Employee implements Comparable<Manager>{…} //ERROR

Manager会实现Comparable<Employee>和Comparable<Manager>,这是同一接口的不同参数化。
这一限制与类型擦除的关系并不十分明显。毕竟，以下非泛型版本是合法的。

class Employee implements Comparable {…}
class Manager extends Employee implements Comparable {…}

其原因非常微妙，有可能与合成的桥方法产生冲突。实现了Comparable<X>的类会获得一个桥方法：

public int compareTo(Object other){return compareTo((X)other);

不能对不同的类型X有两个这样的方法。

泛型的继承规则

假设我们定义了应该泛型类Pair，Manager是Employee的子类，那么它们的继承关系如下

总结一下就是无论S与T有什么关系，通常，Pair<S>与Pair<S>都没有任何关系（如图8-1所示)。

还需要说明的是，泛型类可以扩展或实现其他的泛型类。就这一点而言，它们与普通的类没有什么
区别。

例如，ArrayList类实现了List接口。这意味着，一个ArrayList<Manager>可以转换为一个List<Manager>。但是，如前面所见，ArrayList<Manager>不是一个ArrayList<Employee>或List<Employee>。图8-2展示了它们之间的这种关系。