说明
在这篇文章中，将讨论在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展示了它们之间的这种关系。
总结
对于上面的限制，大家不用全部背下来，再使用泛型的时候慢慢理解就好了
关于泛型的更多知识，参考以下内容
泛型程序设计基础
类型擦除、桥方法、泛型代码和虚拟机
泛型的限制及其继承规则
泛型的通配符(extends,super,?)
