Java基礎-泛型的約束和局限性

????Java中的泛型是一個非常重要知識點，在這里，簡單的介紹一下Java泛型的幾個注意點。這里不會講解Java中的泛型是怎么使用的，只會講解在Java中使用的泛型的注意點

1. 不能使用基本數據類型實例化類型參數

????不能使用類型參數代替基本數據。因此，沒有Pair<double>，只有Pair<Double>(這里我們假設Pair是一個public class Pair<T> 類型的一個類)。這個非常的好理解，想一想我們在使用List集合時，不能這樣子來定義一個集合：List<int> list = new ArrayList<>(),通常都是這樣來定義一個int類型的集合：List<Integer> list = new ArrayList<>();
????這個是什么原因呢？有人可能要問。我們這里需要講一下Java中泛型的類型擦除

(1).Java泛型的類型擦除

????在我們定義一個泛型類的時候，都會自動的給我們提供一個相應的原始類型(這個原始類型不是像Integer對應的是原始數據類型是int)。這里的原始數據類型就是刪除類型參數之后的泛型類型名、擦除類型變量，并且替換為限定類型（如果沒有限定類型，那么就用Object來代替）。
????例如：

擦除類型之前的Pair類

public class Pair<T> {
    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<T extends Comparable & Serializable>{
    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<String>) 

????或者是強制類型轉換：

Pair<String> p = (Pair<String>)a;

同樣的道理，使用getClass方法返回的原始類型：

Pair<String> stringPair = new Pair<>();
Pair<Integer> integerPair = new Pair<>();
if(stringPair.getClass() == integerPair.getClass()){ //true
    
}

????他們的比較結果是true，因為兩次調用getClass方法都將返回的是Pair.class對象，是同一個對象。

3. 不能創建泛型類型的數組

????不能創建泛型類型的數組，例如：

Pair<String> pairs[] = new Pairs<String>[10];

????這個是為什么呢？
????假設，記住這里是假設，如果能夠創建泛型類型的數組，也就是說，我們上面的pairs數組是定義成功了的，那么我們如此操作，編譯器是會報錯的：

pairs[0] = "Hello";

????這個報錯的原因是非常簡單的，Pair<String>類型的數組，不能存儲一個String類型的數據。
????但是類型擦除會導致這個機制失效(類型匹配的機制)。因為如果定義泛型類型的數組成功的話，在擦除類型之后，數組的類型就從Pair<String>[]類型轉換為Pair[],那么Pair[]類型可以變為Object[]類型：

Pair pairs[] = new Pairs[10];//這里重新定義一個Pair類型的數組，表示類型擦除
Object[] obejcts = pairs;//將Pair類型的數組轉換為Object類型的數組
objects[0] = "Hello";//這里就不會報錯，因為這里數組存儲的是Object類型，所以不會報錯。

????由于這個原因--能夠通過數組存儲數組的類型檢查，出于這個原因，不允許創建泛型類型的數組。
????需要說明的是，只是不允許創建泛型類型的數組，而生命類型為Pair<String>[]的變量仍是合法的，只是不允許使用new Pair<String>[10]這種方式來初始化變量。
????注意：可以聲明通配類型的數組，然后進行強制類型轉換：Pair<String> pairs = (Pair<String>[]) new Pair<?>[10]

4. Varagrs警告

????在上一節中，我們已經了解到了Java中不支持泛型類型的數組。這一節中我們再來討論一下相關的問題：向參數個數可變的方法傳遞一個泛型類型的對象。
????例如：

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

????我們知道，在addAll方法中的ts參數是一個數組。
????現在我們這樣調用這個方法：

Collection<Pair<String>> coll = new ArrayList<>();
Pair<String> pair1 = new Pair<>();
Pair<String> pair2 = new Pair<>();
Pair<String> pair3 = new Pair<>();
addAll(coll, pair1, pair2, pair3);

????為了成功的調用addAll方法，Java虛擬機必須為我們創建一個Pair<String>類型的數組，這個就違反了前面的規則。不過，對于這種情況，規則有所放松，這里只是一個警告，而不是錯誤。
????可以采用兩種方法來抑制這個警告。一種方法是在addAll方法的前面增加注解@SuppressWarnings("unchecked");或者在Java7中，還可以使用@SafeVarargs直接標注addAll方法：

@SafeLVarargs
public static <T> void addAll(Collection<T> coll, T...ts)

????注意：
????這里我們可以使用@SafeVarargs注解來消除泛型數組的有關限制，方法如下：

@SafeVarargs
public static <E> E[] array(E...array){
    return array;
}

????現在可以調用：

Pair<String>[] pairs = array(pair1, pair2);

????這個看起來非常的方便，不過隱藏著危險，以下代碼：

Object[] oejcts = pairs;
objects[0] = new Pair<Integer>();

????這里能夠順利運行而且不會出現ArrayStoreException異常(因為數組存儲時，只會檢查擦除之后的類型)，但是在處理pairs[0]時，有可能會在別處得到一個異常。

5. 不能創建泛型類型的變量

????不能使用像new T(...)、new T[...]或者T.class這樣的表達式。例如，下面Pair<T>的構造方法是非法：

public Pair(){
    this.first = new T();
    this.second = new T();
}

????類型擦除之后，將T變為了Object，而且本意上不是調用Object().在Java 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());
}

????這種方式在Java 8比較適用，如果各位讀者對Java 8不是很熟悉的，可以先去看看Java 8中方法引用，這里其實就是將Lambda表達式簡寫成為了方法引用的形式，也就是所謂的語法糖。
????但是在傳統的想法中，我們比較傾向于通過反射調用Class.newInstance方法來創建泛型對象：

first = T.class.newInstance();

????但是遺憾的是，細節比較復雜，而且不能調用。表達式T.class是不合法的，因為擦除之后，類型成為Object.class。所以必須通過以下方法來設計，以便得到一個Class對象：

public static <T> Pair<T> makePair(Class<T> clazz){
    try {
        return new Pair<>(clazz.newInstance(), clazz.newInstance());
    }catch(Exception e) {
        return null;
    }
}

????然后通過如下方法來調用：

Pair<String> pair = Pair.makePair(String.class);

????注意，Class類本身是泛型。例如，String.class是一個Class<String>的對象。因此，makePair方法能夠判斷出pair的類型。

6. 不能構造泛型數組

????就像不能創建一個泛型類型的對象，也不能創建泛型類型的數組。不過原因有所不同，畢竟數組會填充null值，構造是看上去是安全的。不過，數組本身也有類型，用來監控在虛擬機中的數組，這個類型會被擦除。例如：

public static <T extends Comparable> T[] minAndMax(T a[]){
    T ts[] = new T[2];
    ......
    return ts;
}

????類型擦除會讓這個方法永遠構造Comparable類型的數組。
????但是如果數組是一個類的私有成員變量，就可以使用Object類型的數組，并且在獲取元素時，進行類型轉化。例如，ArrayList類可以這樣實現：

public class ArrayList<E>{
    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<E> {
    private E[] elements;
    
    @SuppressWarnings("unchecked")
    public ArrayList() {
        this.elements = (E[])new Object[10];
    }
}

????在minAndMax方法中，由于該方法返回的是一個泛型類型的數組，所以像上面的操作不能進行，但是如果想要實現功能的話，可以如下實現：

public static<T extends > 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 extends Comparable> T[] minAndMax(IntFunction<T[]> constr, T...ts){
    return constr.apply(2);
}

????上面的寫法是基于Java 8中的方法引用。如果使用老式的Java反射，調用Array.newInstance方法：

public static <T extends Comparable> T[] minAndMax(T...a){
    return (T[])Array.newInstance(a.getClass().getComponentType(), 2);
}

7.泛型類的靜態上下文在泛型類型中無效

????靜態變量不能定義泛型類型，靜態方法的返回類型不能定義為泛型類型。例如，下面的寫法是錯誤的：

public class Interval<T>{
    private static T singleInstance; //錯誤，靜態變量的類型不能為泛型類型
    public static T getSingleInstance(){ //錯誤，靜態方法的返回類型為泛型類型。
        return singleInstance;
    }
}

8.不能拋出或者捕獲泛型類的異常

????在Java中，不能對泛型類的異常對象進行拋出捕獲。實際上，泛型類繼承于Throwable類都是不合法的，例如，以下的代碼是錯誤的：

public class Problem<T> extends Throwable{
    
}

????同時不能再catch語句中使用泛型類型的異常對象。例如：

public static <T extends Throwable> void doWork(Class<T> clazz){
    try{
        
    }catch(T e){ //錯誤，不能拋出泛型類型的異常對象
        
    }
}

????不過，在異常規范中，使用泛型類型的對象是允許的：

public static <T extends Throwable> 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 <T extends Throwable> 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里面拋出