一、不能用类型参数代替基本类型
因为类型擦除之后，原本的类型会被替代为Object类型的域，而Object不能存储基本类型的值。就是说没有Pair<double>，取而代之的是该基本类型的包装器类型Pair<Double>
二、运行时类型查询之适用于原始类型
这句话怎么理解呢？也就是说
a instanceof Pair<String> //错误
a instanceof Pair<T> //同样是错误
而使用getClass：
Pair<String> stringPair = ...;
Pair<Employee> employeePair = ...;
if (stringPair.getClass() == employeePair.getClass()) //true
这里比较的结果为什么为true呢？因为两次调用getClass都会返回Pair.class，即该泛型类的原始类型，这就是类型擦除所起到的作用。
三、不能创建参数化类型的数组
因为在经过了类型擦除之后，我们所规定的类型被类型擦除之后无效，不仅可以存入我们所规定的类型，同样的也可以存入其他类型的值。
Pair<String>[] table = new Pair<String>[10];
//擦除之后，table的类型是Pair[], 可以把它转换为Object[]
Object[] objArr = table;
//这里可以通过数组类型存储检查，但是仍会导致一个类型错误
objArr[0] = new Pair<Employee>();
所以，我们不能创建参数化类型的数组，这里需要注意的是，我们仅仅是不能创建，但是声明类型为Pair<String>[]的变量仍是合法的。不过不能去初始化这个变量。
如果我们想要收集参数化类型对象，只有一种安全且有效的方法：
ArrayList<Pair<String>> = new ArrayList<>();
四、Varargs警告
如果我们向参数个数可变的方法传递一个泛型类型的实例
public static <T> void addAll(Collection<T> coll, T... ts) {
for (t: ts) {
coll.add(t);
}
}
我们现在去调用这个方法：
Collection<Pair<String>> table = ...;
Pair<String> pair1 = ...;
Pair<String> pair2 = ...;
addAll(table, pair1, pair2);
为了调用这个方法，Java虚拟机必须创建一个Pair<String>数组，但是这样就会违反了前面上一条的规则。但是对于这种情况，规则有所放松，我们只会得到一个警告，而不是错误。
我们可以使用@SuppressWarnings("unchecked")或@SafeVarargs标注这个方法。
但是这里会存在安全隐患：
static <E> array(E... array) {
return array;
}
//调用这个方法：
Pair<String>[] table = array(pair1, pair2);
Object objArr = table;
objArr[0] = new Pair<Employee>();
这里可以顺利运行而不出出现ArrayStoreException，因为数组存储只会检查擦除的类型，但是当我们处理table[0]时会在别处得到一个异常。所以当我们需要想参数个数可变的方法传一个泛型类型的实例的时候，一定要注意，而不是无脑的去加上注释抑制这个警告。
五、不能实例化类型变量
不能使用像new T(...)，new T[...]或T.class这样的表达式中的类型变量。下面是一个错误的例子：
public Pair() {
first = new T();
second = new T();
}
因为类型擦除会将T改变成Object，而且，本意肯定不希望调用new Object()。在Java SE 8之后，最好解决方法是让调用者提供一个构造器表达式。例如：
Pair<String> p = Pair.makePair(String::new);
makePair方法接收一个Supplier<T>，这是一个函数式接口，表示一个无参数而且返回类型为T的函数：
public static <T> Pair<T> makePair(Supplier<T> constr) {
return new Pair<>(constr.get(), constr.get());
}
或者通过Class.newInstance方法来构造泛型对象。
public static <T> Pair<T> makePair(Class<T> cl) {
try {
return new Pair<>(cl.newInstance(), cl.newInstance());
} catch (Exception ex) {
return null;
}
}
这个方法可以按照下列方式调用：
Pair<String> p = Pair.makePair(String.class);
注意，Class类本身是泛型，String.class就是一个Class<String>的实例，因此makePair方法能够推断出pair的类型。
六、不能构造泛型数组
public static <T extends Comparable> T[] minmax(T[] a) {
T[] mm = new T[2];
}
类型擦除会让这个方法永远构造Comparable[2]数组。
如果数组仅仅作为一个类的私有实例域，就可以将这个数组声明为Object[],并且在获取元素的时候进行类型转换。例如，ArrayList类可以这么实现：
public class ArrayList<E> {
private Object[] elements;
@SuppressWarnings("unchecked")
public E get(int n) {
return (E)elements[n];
}
public void set(int n, E e) {
elements[n] = e;
}
}
如果按照这个思路去改造上面的代码：
public static <T extends Comparable> T[] minmax(T[] a) {
Object[] mm = new Object[2];
return (T[]) mm;
}
这样做，虽然在编译的时候没有任何警告，但是在运行的时候会将Object[]引用赋给Comparable[]变量的时候，会抛出一个ClassNotCastException异常。
对于这种情况，我们有两种解决方案，可以让用户提供一个数组构造器表达式：
String[] ss = ArrayAlg.minmax(String[]::new, "Tom", "Dick", "Harry");
构造器表达式String::new指示一个函数，给定所需的长度，会构造一个指定长度的String数组。
minmax方法使用这个参数生产一个有正确类型的数组：
public static <T extends Comparable> T[] minmax(IntFunction<T[]> constr, T... a) {
T[] mm = constr.apply(2);
T min = a[0];
T max = a[0];
for (int i = 1; i < a.length; i++) {
if (min.compareTo(a[i]) > 0) min = a[i];
if (max.compareTo(a[i]) < 0) max = a[i];
}
return mm;
}
或者使用反射也可以达到这个效果：
public static <T extends Comparable> T[] minmax(T... a){
T[] mm = (T[]) Array.newInstance(a.getClass().getComponentType(), 2);
T min = a[0];
T max = a[0];
for (int i = 1; i < a.length; i++) {
if (min.compareTo(a[i]) > 0) min = a[i];
if (max.compareTo(a[i]) < 0) max = a[i];
}
return (T[]) mm;
}
七、泛型类的静态上下文中类型变量无效
不能在静态域或方法中引用类型变量，例如下面的代码就是错误的：
public class Singleton<T> {
private static T singleInstance; //错误
public static T getSingleInstance() {
return singleInstance;
}
}
八、不能抛出或捕获泛型类的实例
既不能抛出也不能捕获泛型类对象，实际上，甚至泛型类扩展Throwable都是不合法的。例如下面的代码：
public class Problem<T> extends Exception {...}
catch 子句中不能使用类型变量。例如，以下方法将不能通过编译：
public static <T extends Throwable> void doWork(Class<T> t) {
try {
//do work
}catch (T e) { //不能catch类型变量
...
}
}
不过，在异常规范中使用类型变量是允许的
public static <T extends Throwable> void doWork(T t) throws T {
try {
//do work
} catch (Throwable realCause) {
t.initCause(realCause);
throw t;
}
}
九、可以消除对受查异常的检查
Java异常处理的一个基本原则是，必须为所有受查异常提供一个处理器。不过可以利用泛型消除这个限制。
@SuppressWarnings("unchecked")
public static <T extends Throwable> void throwAs(Throwable e) throws T {
throw (T) e;
}
假如这个方法包含在类Block中，如果调用
Block.<RuntimeException>throwAs(t);
编译器就会认为t是一个非受查异常。以下代码就会把所有异常都转换为编译器所认为的非受查异常：
try {
//do work
} catch (Throwable t) {
Block.<RuntimeExcetion>throwAs(t);
}
下面把这个代码包装到一个抽象类中。用户可以覆盖body方法来提供一个具体的动作。调用toThread时，会得到Thread类的一个对象，它的run方法不会介意受查异常。
public abstract class Block {
public abstract void body() throws Exception;
public Thread toThread() {
return new Thread() {
public void run() {
try{
body();
} catch (Throwable t) {
Block.<RuntimeException>throwAs(t);
}
}
}
}
public static <T extends Throwable> void throwAs(Throwable e) throws T {
throw (T) e;
}
}
现在我们写一个程序来运行一个线程，它会抛出一个受查异常
public class Test {
public static void main(String[] args) {
new Block() {
public void body() throws Exception {
Scanner in = new Scanner(new File("1231"), "UTF-8");
while (in.hasNext()) {
System.out.println(in.next())
}
}
}.toThread().start();
}
}
运行这个程序的时候，会得到一个栈轨迹，其中包含一个FileNotFoundException。这就意味着，在正常情况下，我们必须捕获线程run方法中的所有受查异常，把他们包装到非受查异常中，因为run方法声明为不抛出任何受查异常。
但是我们在这里并没有进行这种包装，我们只是抛出异常，并哄骗编译器，让它认为这不是一个受查异常。
公众号
扫码或微信搜索 Vi的技术博客，关注公众号，不定期送书活动各种福利~
