Java基础-泛型的约束和局限性
Java中的泛型是一个非常重要知识点，在这里，简单的介绍一下Java泛型的几个注意点。这里不会讲解Java中的泛型是怎么使用的，只会讲解在Java中使用的泛型的注意点
1. 不能使用基本数据类型实例化类型参数
不能使用类型参数代替基本数据。因此，没有Pair
这个是什么原因呢？有人可能要问。我们这里需要讲一下Java中泛型的类型擦除
(1).Java泛型的类型擦除
在我们定义一个泛型类的时候，都会自动的给我们提供一个相应的原始类型(这个原始类型不是像Integer对应的是原始数据类型是int)。这里的原始数据类型就是删除类型参数之后的泛型类型名、擦除类型变量，并且替换为限定类型（如果没有限定类型，那么就用Object来代替）。
例如：
擦除类型之前的Pair类
public class Pair {
private T first = null;
private T second = null;
public Pair() {
this.first = null;
this.second = null;
}
public Pair(T first, T second) {
this.first = first;
this.second = second;
}
public void setFirst(T first) {
this.first = first;
}
public void setSecond(T second) {
this.second = second;
}
public T getFirst() {
return first;
}
public T getSecond() {
return second;
}
}
擦除类型之后的Pair类
public class Pair {
private Object first;
private Object second;
public Pair() {
this.first = null;
this.second = null;
}
public Pair(Object first, Object second) {
this.first = first;
this.second = second;
}
public void setFirst(Object first) {
this.first = first;
}
public void setSecond(Object second) {
this.second = second;
}
public Object getFirst() {
return first;
}
public Object getSecond() {
return second;
}
}
我们会发现在在擦除之前，Pair里面的成员变量类型都是T类型，也就是泛型类型。但是在擦除之后，所有T类型都变成了Object类型。这个也就是我们之前说的，如果一个类型是无限定类型的话，会被替换成为Object类型。
如果泛型类型被限制了的，也就是T extends其他的类或者接口，就取extends关键字之后第一个类型来作为擦除之后的类型。为什么这里要强调是extends关键字之后第一个类型呢？因为extends关键字之后可以跟多个类或者接口，多个类或者接口使用&来连接。
例如，可以这样写：
public class Interval{
private T lower;
private T upper;
.....
}
擦除类型之后：
public class Interval{
private Comparable lower;
private Comparable upper;
......
}
(2).不用基本数据类型的原因
非常的明显，这里的原因肯定是类型擦除导致的。擦除之后，Pair类含有Object类型的成员变量，但是Object不能存储double类型的值。
2.运行时类型查询只适用于原始类型
在Java中，我们知道可以使用instanceof关键字来判断一个引用是否是一个类的对象。在泛型里面，这种代码是不支持的：
if(a instanceof Pair)
或者是强制类型转换：
Pair p = (Pair)a;
同样的道理，使用getClass方法返回的原始类型：
Pair stringPair = new Pair<>();
Pair integerPair = new Pair<>();
if(stringPair.getClass() == integerPair.getClass()){ //true
}
他们的比较结果是true，因为两次调用getClass方法都将返回的是Pair.class对象，是同一个对象。
3. 不能创建泛型类型的数组
不能创建泛型类型的数组，例如：
Pair pairs[] = new Pairs[10];
这个是为什么呢？
假设，记住这里是假设，如果能够创建泛型类型的数组，也就是说，我们上面的pairs数组是定义成功了的，那么我们如此操作，编译器是会报错的：
pairs[0] = "Hello";
这个报错的原因是非常简单的，Pair
但是类型擦除会导致这个机制失效(类型匹配的机制)。因为如果定义泛型类型的数组成功的话，在擦除类型之后，数组的类型就从Pair
Pair pairs[] = new Pairs[10];//这里重新定义一个Pair类型的数组，表示类型擦除
Object[] obejcts = pairs;//将Pair类型的数组转换为Object类型的数组
objects[0] = "Hello";//这里就不会报错，因为这里数组存储的是Object类型，所以不会报错。
由于这个原因--能够通过数组存储数组的类型检查，出于这个原因，不允许创建泛型类型的数组。
需要说明的是，只是不允许创建泛型类型的数组，而生命类型为Pair
注意：可以声明通配类型的数组，然后进行强制类型转换：Pair
4. Varagrs警告
在上一节中，我们已经了解到了Java中不支持泛型类型的数组。这一节中我们再来讨论一下相关的问题：向参数个数可变的方法传递一个泛型类型的对象。
例如：
public static void addAll(Collection coll, T...ts){
for(T t:ts){
coll.add(t);
}
}
我们知道，在addAll方法中的ts参数是一个数组。
现在我们这样调用这个方法：
Collection> coll = new ArrayList<>();
Pair pair1 = new Pair<>();
Pair pair2 = new Pair<>();
Pair pair3 = new Pair<>();
addAll(coll, pair1, pair2, pair3);
为了成功的调用addAll方法，Java虚拟机必须为我们创建一个Pair
可以采用两种方法来抑制这个警告。一种方法是在addAll方法的前面增加注解@SuppressWarnings("unchecked");或者在Java7中，还可以使用@SafeVarargs直接标注addAll方法：
@SafeLVarargs
public static void addAll(Collection coll, T...ts)
注意：
这里我们可以使用@SafeVarargs注解来消除泛型数组的有关限制，方法如下：
@SafeVarargs
public static E[] array(E...array){
return array;
}
现在可以调用：
Pair[] pairs = array(pair1, pair2);
这个看起来非常的方便，不过隐藏着危险，以下代码：
Object[] oejcts = pairs;
objects[0] = new Pair();
这里能够顺利运行而且不会出现ArrayStoreException异常(因为数组存储时，只会检查擦除之后的类型)，但是在处理pairs[0]时，有可能会在别处得到一个异常。
5. 不能创建泛型类型的变量
不能使用像new T(...)、new T[...]或者T.class这样的表达式。例如，下面Pair
public Pair(){
this.first = new T();
this.second = new T();
}
类型擦除之后，将T变为了Object，而且本意上不是调用Object().在Java 8 出现之后，最好的解决办法是：让调用提供一个构造器的表达式，例如：
Pair p = Pair.makePair(String::new);
makePair方法接收一个Supplier
public static Pair makePair(Supplier constr){
return new Pair<>(constr.get(), constr.get());
}
这种方式在Java 8比较适用，如果各位读者对Java 8不是很熟悉的，可以先去看看Java 8中方法引用，这里其实就是将Lambda表达式简写成为了方法引用的形式，也就是所谓的语法糖。
但是在传统的想法中，我们比较倾向于通过反射调用Class.newInstance方法来创建泛型对象：
first = T.class.newInstance();
但是遗憾的是，细节比较复杂，而且不能调用。表达式T.class是不合法的，因为擦除之后，类型成为Object.class。所以必须通过以下方法来设计，以便得到一个Class对象：
public static Pair makePair(Class clazz){
try {
return new Pair<>(clazz.newInstance(), clazz.newInstance());
}catch(Exception e) {
return null;
}
}
然后通过如下方法来调用：
Pair pair = Pair.makePair(String.class);
注意，Class类本身是泛型。例如，String.class是一个Class
6. 不能构造泛型数组
就像不能创建一个泛型类型的对象，也不能创建泛型类型的数组。不过原因有所不同，毕竟数组会填充null值，构造是看上去是安全的。不过，数组本身也有类型，用来监控在虚拟机中的数组，这个类型会被擦除。例如：
public static T[] minAndMax(T a[]){
T ts[] = new T[2];
......
return ts;
}
类型擦除会让这个方法永远构造Comparable类型的数组。
但是如果数组是一个类的私有成员变量，就可以使用Object类型的数组，并且在获取元素时，进行类型转化。例如，ArrayList类可以这样实现：
public class ArrayList{
private Object[] elements;
......
@SuppressWarnings("unchecked")
public E get(int index){
return (E)elements[index];
}
public void set(E e, int index){
elements[index] = e;
}
}
实际上也可以这样写：
public class ArrayList {
private E[] elements;
@SuppressWarnings("unchecked")
public ArrayList() {
this.elements = (E[])new Object[10];
}
}
在minAndMax方法中，由于该方法返回的是一个泛型类型的数组，所以像上面的操作不能进行，但是如果想要实现功能的话，可以如下实现：
public static T[] minAndMax(T...ts){
Object[] objects = new Object[10];
......
return (T[]) objects;
}
然后调用代码：
String ss[] = ArrayAlg.minAndMax("pby", "pby123", "pby456");
上面这段代码在编译阶段是没有错误的，但是当我们调用这个方法会抛出一个ClassCastException异常。
在这种情况下，可以让用户提供一个数组的构造器表达式：
String [] ss = ArrayAlg.minAndMax(String[]::new, "pby", "pby123", "pby456");
然后在minAndMax方法中使用这个参数生成一个正确类型的数组：
public static T[] minAndMax(IntFunction constr, T...ts){
return constr.apply(2);
}
上面的写法是基于Java 8中的方法引用。如果使用老式的Java反射，调用Array.newInstance方法：
public static T[] minAndMax(T...a){
return (T[])Array.newInstance(a.getClass().getComponentType(), 2);
}
7.泛型类的静态上下文在泛型类型中无效
静态变量不能定义泛型类型，静态方法的返回类型不能定义为泛型类型。例如，下面的写法是错误的：
public class Interval{
private static T singleInstance; //错误，静态变量的类型不能为泛型类型
public static T getSingleInstance(){ //错误，静态方法的返回类型为泛型类型。
return singleInstance;
}
}
8.不能抛出或者捕获泛型类的异常
在Java中，不能对泛型类的异常对象进行抛出捕获。实际上，泛型类继承于Throwable类都是不合法的，例如，以下的代码是错误的：
public class Problem extends Throwable{
}
同时不能再catch语句中使用泛型类型的异常对象。例如：
public static void doWork(Class clazz){
try{
}catch(T e){ //错误，不能抛出泛型类型的异常对象
}
}
不过，在异常规范中，使用泛型类型的对象是允许的：
public static void doWork(T t){
throws T
try{
}catch(Throwable realCause){
t.initCause(realCause);
throw t;
}
}
9. 可以消除对受查异常的检查
Java异常处理的一个基本规则是：必须为所有受查异常提供一个处理器。不过我们可以利用这个泛型来取消这个限制。例如：
public abstract class Block {
public abstract void body() throws Exception;
public Thread toThread() {
return new Thread() {
@Override
public void run() {
try {
body();
}catch(Throwable t) {
Block.throwAs(t);
}
}
};
}
@SuppressWarnings("unchecked")
public static void throwAs(Throwable t) throws T{
throw (T) t;
}
}
然后我们在main方法里面开启一个线程来调用我们的方法。
public class Demo {
public static void main(String []args) {
new Block() {
@Override
public void body() throws Exception{
}
}.toThread().start();
}
}
有人可能会问这个有什么意义上呢？正常情况下，我们必须捕获run方法里面所有受查异常，不能从run方法里面向外面抛出一个异常，因为在Thread类里面的run方法没有抛出任何的异常，所以我们这里向外抛出任何的异常，所有的受查异常都必须爱run方法里面进行捕获。但是我们这里的操作就是，将受查异常包装为非受查异常，然后在catch里面抛出