Java 泛型，你瞭解類型擦除嗎？

泛型，一個孤獨的守門者。

你們可能會有疑問，我爲何叫作泛型是一個守門者。這實際上是我我的的見解而已，個人意思是說泛型沒有其看起來那麼深不可測，它並不神祕與神奇。泛型是 Java 中一個很小巧的概念，但同時也是一個很容易讓人迷惑的知識點，它讓人迷惑的地方在於它的許多表現有點違反直覺。

文章開始的地方，先給你們奉上一道經典的測試題。

List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();

System.out.println(l1.getClass() == l2.getClass());

請問，上面代碼最終結果輸出的是什麼？不瞭解泛型的和很熟悉泛型的同窗應該可以答出來，而對泛型有所瞭解，可是瞭解不深刻的同窗可能會答錯。

正確答案是 true。

上面的代碼中涉及到了泛型，而輸出的結果原因是類型擦除。先好好說說泛型。

泛型是什麼？

泛型的英文是 generics，generic 的意思是通用,而翻譯成中文，泛應該意爲普遍，型是類型。因此泛型就是能普遍適用的類型。

但泛型還有一種較爲準確的說法就是爲了參數化類型，或者說能夠將類型看成參數傳遞給一個類或者是方法。

那麼，如何解釋類型參數化呢？

public class Cache {
    Object value;

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

}

假設 Cache 可以存取任何類型的值，因而，咱們能夠這樣使用它。

Cache cache = new Cache();
cache.setValue(134);
int value = (int) cache.getValue();
cache.setValue("hello");
String value1 = (String) cache.getValue();

使用的方法也很簡單，只要咱們作正確的強制轉換就行了。

可是，泛型卻給咱們帶來了不同的編程體驗。

public class Cache<T> {
    T value;

    public Object getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

}

這就是泛型，它將 value 這個屬性的類型也參數化了，這就是所謂的參數化類型。再看它的使用方法。

Cache<String> cache1 = new Cache<String>();
cache1.setValue("123");
String value2 = cache1.getValue();

Cache<Integer> cache2 = new Cache<Integer>();
cache2.setValue(456);
int value3 = cache2.getValue();

最顯而易見的好處就是它再也不須要對取出來的結果進行強制轉換了。但，還有另一點不一樣。 
 
泛型除了能夠將類型參數化外，而參數一旦肯定好，若是相似不匹配，編譯器就不經過。 
上面代碼顯示，沒法將一個 String 對象設置到 cache2 中，由於泛型讓它只接受 Integer 的類型。

因此，綜合上面信息，咱們能夠獲得下面的結論。

1. 與普通的 Object 代替一切類型這樣簡單粗暴而言，泛型使得數據的類別能夠像參數同樣由外部傳遞進來。它提供了一種擴展能力。它更符合面向抽象開發的軟件編程宗旨。
2. 當具體的類型肯定後，泛型又提供了一種類型檢測的機制，只有相匹配的數據才能正常的賦值，不然編譯器就不經過。因此說，它是一種類型安全檢測機制，必定程度上提升了軟件的安全性防止出現低級的失誤。
3. 泛型提升了程序代碼的可讀性，沒必要要等到運行的時候纔去強制轉換，在定義或者實例化階段，由於 Cache<String> 這個類型顯化的效果，程序員可以一目瞭然猜想出代碼要操做的數據類型。

下面的文章，咱們正常介紹泛型的相關知識。

泛型的定義和使用

泛型按照使用狀況能夠分爲 3 種。 
1. 泛型類。 
2. 泛型方法。 
3. 泛型接口。

泛型類

咱們能夠這樣定義一個泛型類。

public class Test<T> {
    T field1;
}

尖括號 <> 中的 T 被稱做是類型參數，用於指代任何類型。事實上，T 只是一種習慣性寫法，若是你願意。你能夠這樣寫。

public class Test<Hello> {
    Hello field1;
}

但出於規範的目的，Java 仍是建議咱們用單個大寫字母來表明類型參數。常見的如： 
1. T 表明通常的任何類。 
2. E 表明 Element 的意思，或者 Exception 異常的意思。 
3. K 表明 Key 的意思。 
4. V 表明 Value 的意思，一般與 K 一塊兒配合使用。 
5. S 表明 Subtype 的意思，文章後面部分會講解示意。

若是一個類被 <T> 的形式定義，那麼它就被稱爲是泛型類。

那麼對於泛型類怎麼樣使用呢？

Test<String> test1 = new Test<>();
Test<Integer> test2 = new Test<>();

只要在對泛型類建立實例的時候，在尖括號中賦值相應的類型即是。T 就會被替換成對應的類型，如 String 或者是 Integer。你能夠相像一下，當一個泛型類被建立時，內部自動擴展成下面的代碼。

public class Test<String> {
    String field1;
}

固然，泛型類不至接受一個類型參數，它還能夠這樣接受多個類型參數。

public class MultiType <E,T>{
    E value1;
    T value2;

    public E getValue1(){
        return value1;
    }

    public T getValue2(){
        return value2;
    }
}

泛型方法

public class Test1 {

    public <T> void testMethod(T t){

    }
}

泛型方法與泛型類稍有不一樣的地方是，類型參數也就是尖括號那一部分是寫在返回值前面的。<T> 中的 T 被稱爲類型參數，而方法中的 T 被稱爲參數化類型，它不是運行時真正的參數。

固然，聲明的類型參數，其實也是能夠看成返回值的類型的。

public  <T> T testMethod1(T t){
        return null;
}

泛型類與泛型方法的共存現象

public class Test1<T>{

    public  void testMethod(T t){
        System.out.println(t.getClass().getName());
    }
    public  <T> T testMethod1(T t){
        return t;
    }
}

上面代碼中，Test1<T> 是泛型類，testMethod 是泛型類中的普通方法，而 testMethod1 是一個泛型方法。而泛型類中的類型參數與泛型方法中的類型參數是沒有相應的聯繫的，泛型方法始終以本身定義的類型參數爲準。

因此，針對上面的代碼，咱們能夠這樣編寫測試代碼。

Test1<String> t = new Test1();
t.testMethod("generic");
Integer i = t.testMethod1(new Integer(1));

泛型類的實際類型參數是 String，而傳遞給泛型方法的類型參數是 Integer，二者不想幹。

可是，爲了不混淆，若是在一個泛型類中存在泛型方法，那麼二者的類型參數最好不要同名。好比，Test1<T> 代碼能夠更改成這樣

public class Test1<T>{

    public  void testMethod(T t){
        System.out.println(t.getClass().getName());
    }
    public  <E> E testMethod1(E e){
        return e;
    }
}

泛型接口

泛型接口和泛型類差很少，因此一筆帶過。

public interface Iterable<T> {
}

• 1
• 2

通配符 ？

除了用 <T> 表示泛型外，還有 <?> 這種形式。？ 被稱爲通配符。

可能有同窗會想，已經有了 <T> 的形式了，爲何還要引進 <?> 這樣的概念呢？

class Base{}

class Sub extends Base{}

Sub sub = new Sub();
Base base = sub;

上面代碼顯示，Base 是 Sub 的父類，它們之間是繼承關係，因此 Sub 的實例能夠給一個 Base 引用賦值，那麼

List<Sub> lsub = new ArrayList<>();
List<Base> lbase = lsub;

最後一行代碼成立嗎？編譯會經過嗎？

答案是否認的。

編譯器不會讓它經過的。Sub 是 Base 的子類，不表明 List<Sub> 和 List<Base> 有繼承關係。

可是，在現實編碼中，確實有這樣的需求，但願泛型可以處理某一範圍內的數據類型，好比某個類和它的子類，對此 Java 引入了通配符這個概念。

因此，通配符的出現是爲了指定泛型中的類型範圍。

通配符有 3 種形式。

1. <?> 被稱做無限定的通配符。
2. <? extends T> 被稱做有上限的通配符。
3. <? super T> 被稱做有下限的通配符。

無限定通配符

public void testWildCards(Collection<?> collection){
}

• 1
• 2

上面的代碼中，方法內的參數是被無限定通配符修飾的 Collection 對象，它隱略地表達了一個意圖或者能夠說是限定，那就是 testWidlCards() 這個方法內部無需關注 Collection 中的真實類型，由於它是未知的。因此，你只能調用 Collection 中與類型無關的方法。 

咱們能夠看到，當 <?> 存在時，Collection 對象喪失了 add() 方法的功能，編譯器不經過。 
咱們再看代碼。

List<?> wildlist = new ArrayList<String>();
wildlist.add(123);// 編譯不經過

有人說，<?> 提供了只讀的功能，也就是它刪減了增長具體類型元素的能力，只保留與具體類型無關的功能。它無論裝載在這個容器內的元素是什麼類型，它只關心元素的數量、容器是否爲空？我想這種需求仍是很常見的吧。

有同窗可能會想，<?> 既然做用這麼眇小，那麼爲何還要引用它呢？

我的認爲，提升了代碼的可讀性，程序員看到這段代碼時，就可以迅速對此創建極簡潔的印象，可以快速推斷源碼做者的意圖。

<? extends T>

<?> 表明着類型未知，可是咱們的確須要對於類型的描述再精確一點，咱們但願在一個範圍內肯定類別，好比類型 A 及 類型 A 的子類均可以。

 

public void testSub(Collection<? extends Base> para){

}

上面代碼中，para 這個 Collection 接受 Base 及 Base 的子類的類型。

可是，它仍然喪失了寫操做的能力。也就是說

para.add(new Sub());
para.add(new Base());

仍然編譯不經過。

沒有關係，咱們不知道具體類型，可是咱們至少清楚了類型的範圍。

<? super T>

這個和 <? extends T> 相對應，表明 T 及 T 的超類。

public void testSuper(Collection<? super Sub> para){
}

<? super T> 神奇的地方在於，它擁有必定程度的寫操做的能力。

public void testSuper(Collection<? super Sub> para){
    para.add(new Sub());//編譯經過
    para.add(new Base());//編譯不經過
}

通配符與類型參數的區別

通常而言，通配符能幹的事情均可以用類型參數替換。 
好比

public void testWildCards(Collection<?> collection){}

能夠被

public <T> void test(Collection<T> collection){}

取代。

值得注意的是，若是用泛型方法來取代通配符，那麼上面代碼中 collection 是可以進行寫操做的。只不過要進行強制轉換。

public <T> void test(Collection<T> collection){
    collection.add((T)new Integer(12));
    collection.add((T)"123");
}

須要特別注意的是，類型參數適用於參數之間的類別依賴關係，舉例說明。

public class Test2 <T,E extends T>{
    T value1;
    E value2;
}

public <D,S extends D> void test(D d,S s){

    }

E 類型是 T 類型的子類，顯然這種狀況類型參數更適合。 
有一種狀況是，通配符和類型參數一塊兒使用。

public <T> void test(T t,Collection<? extends T> collection){

}

若是一個方法的返回類型依賴於參數的類型，那麼通配符也無能爲力。

public T test1(T t){
    return value1;
}

類型擦除

泛型是 Java 1.5 版本才引進的概念，在這以前是沒有泛型的概念的，但顯然，泛型代碼可以很好地和以前版本的代碼很好地兼容。

這是由於，泛型信息只存在於代碼編譯階段，在進入 JVM 以前，與泛型相關的信息會被擦除掉，專業術語叫作類型擦除。

通俗地講，泛型類和普通類在 java 虛擬機內是沒有什麼特別的地方。回顧文章開始時的那段代碼

List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();

System.out.println(l1.getClass() == l2.getClass());

打印的結果爲 true 是由於 List<String> 和 List<Integer> 在 jvm 中的 Class 都是 List.class。

泛型信息被擦除了。

可能同窗會問，那麼類型 String 和 Integer 怎麼辦？

答案是泛型轉譯。

public class Erasure <T>{
    T object;

    public Erasure(T object) {
        this.object = object;
    }

}

Erasure 是一個泛型類，咱們查看它在運行時的狀態信息能夠經過反射。

Erasure<String> erasure = new Erasure<String>("hello");
Class eclz = erasure.getClass();
System.out.println("erasure class is:"+eclz.getName());

打印的結果是

erasure class is:com.frank.test.Erasure

• 1

Class 的類型仍然是 Erasure 並非 Erasure<T> 這種形式，那咱們再看看泛型類中 T 的類型在 jvm 中是什麼具體類型。

Field[] fs = eclz.getDeclaredFields();
for ( Field f:fs) {
    System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());
}

打印結果是

Field name object type:java.lang.Object

• 1

那咱們可不能夠說，泛型類被類型擦除後，相應的類型就被替換成 Object 類型呢？

這種說法，不徹底正確。

咱們更改一下代碼。

public class Erasure <T extends String>{
//  public class Erasure <T>{
    T object;

    public Erasure(T object) {
        this.object = object;
    }

}

如今再看測試結果：

Field name object type:java.lang.String

• 1

咱們如今能夠下結論了，在泛型類被類型擦除的時候，以前泛型類中的類型參數部分若是沒有指定上限，如 <T> 則會被轉譯成普通的 Object 類型，若是指定了上限如 <T extends String> 則類型參數就被替換成類型上限。

因此，在反射中。

public class Erasure <T>{
    T object;

    public Erasure(T object) {
        this.object = object;
    }

    public void add(T object){

    }

}

add() 這個方法對應的 Method 的簽名應該是 Object.class。

Erasure<String> erasure = new Erasure<String>("hello");
Class eclz = erasure.getClass();
System.out.println("erasure class is:"+eclz.getName());

Method[] methods = eclz.getDeclaredMethods();
for ( Method m:methods ){
    System.out.println(" method:"+m.toString());
}

打印結果是

method:public void com.frank.test.Erasure.add(java.lang.Object)

• 1

也就是說，若是你要在反射中找到 add 對應的 Method，你應該調用 getDeclaredMethod("add",Object.class) 不然程序會報錯，提示沒有這麼一個方法，緣由就是類型擦除的時候，T 被替換成 Object 類型了。

類型擦除帶來的侷限性

類型擦除，是泛型可以與以前的 java 版本代碼兼容共存的緣由。但也由於類型擦除，它會抹掉不少繼承相關的特性，這是它帶來的侷限性。

理解類型擦除有利於咱們繞過開發當中可能遇到的雷區，一樣理解類型擦除也能讓咱們繞過泛型自己的一些限制。好比 

正常狀況下，由於泛型的限制，編譯器不讓最後一行代碼編譯經過，由於相似不匹配，可是，基於對類型擦除的瞭解，利用反射，咱們能夠繞過這個限制。

public interface List<E> extends Collection<E>{

     boolean add(E e);
}

上面是 List 和其中的 add() 方法的源碼定義。

由於 E 表明任意的類型，因此類型擦除時，add 方法其實等同於

boolean add(Object obj);

• 1

那麼，利用反射，咱們繞過編譯器去調用 add 方法。

public class ToolTest {


    public static void main(String[] args) {
        List<Integer> ls = new ArrayList<>();
        ls.add(23);
//      ls.add("text");
        try {
            Method method = ls.getClass().getDeclaredMethod("add",Object.class);


            method.invoke(ls,"test");
            method.invoke(ls,42.9f);
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for ( Object o: ls){
            System.out.println(o);
        }

    }

}

打印結果是：

23
test
42.9

能夠看到，利用類型擦除的原理，用反射的手段就繞過了正常開發中編譯器不容許的操做限制。

泛型中值得注意的地方

泛型類或者泛型方法中，不接受 8 種基本數據類型。

因此，你沒有辦法進行這樣的編碼。

List<int> li = new ArrayList<>();
List<boolean> li = new ArrayList<>();

須要使用它們對應的包裝類。

List<Integer> li = new ArrayList<>();
List<Boolean> li1 = new ArrayList<>();

對泛型方法的困惑

public <T> T test(T t){
    return null;
}

有的同窗可能對於連續的兩個 T 感到困惑，其實 <T> 是爲了說明類型參數，是聲明,然後面的不帶尖括號的 T 是方法的返回值類型。 
你能夠相像一下，若是 test() 這樣被調用

test("123");

•  

那麼實際上至關於

public String test(String t);

•  

Java 不能建立具體類型的泛型數組

這句話可能難以理解，代碼說明。

List<Integer>[] li2 = new ArrayList<Integer>[];
List<Boolean> li3 = new ArrayList<Boolean>[];

這兩行代碼是沒法在編譯器中編譯經過的。緣由仍是類型擦除帶來的影響。

List 和 List 在 jvm 中等同於 List ，全部的類型信息都被擦除，程序也沒法分辨一個數組中的元素類型具體是 List 類型仍是 List 類型。

可是，

List<?>[] li3 = new ArrayList<?>[10];
li3[1] = new ArrayList<String>();
List<?> v = li3[1];

藉助於無限定通配符卻能夠，前面講過 ？ 表明未知類型，因此它涉及的操做都基本上與類型無關，所以 jvm 不須要針對它對類型做判斷，所以它能編譯經過，可是，只提供了數組中的元素由於通配符緣由，它只能讀，不能寫。好比，上面的 v 這個局部變量，它只能進行 get() 操做，不能進行 add() 操做，這個在前面通配符的內容小節中已經講過。

泛型，並不神奇

咱們能夠看到，泛型其實並無什麼神奇的地方，泛型代碼能作的非泛型代碼也能作。

而類型擦除，是泛型可以與以前的 java 版本代碼兼容共存的緣由。

可量也正由於類型擦除致使了一些隱患與侷限。

但，我仍是要建議你們使用泛型，如官方文檔所說的，若是可使用泛型的地方，儘可能使用泛型。

畢竟它抽離了數據類型與代碼邏輯，本意是提升程序代碼的簡潔性和可讀性，並提供可能的編譯時類型轉換安全檢測功能。

類型擦除不是泛型的所有，可是它卻能很好地檢測咱們對於泛型這個概念的理解程度。

我在文章開頭將泛型比做是一個守門人，緣由就是他本意是好的，守護咱們的代碼安全，而後在門牌上寫着出入的各項規定，及「xxx 禁止出入」的提醒。可是同咱們平常所遇到的那些門衛通常，他們古怪偏執，死板守舊，咱們能夠利用反射基於類型擦除的認識，來繞過泛型中某些限制，現實生活中，也總會有調皮搗蛋者可以基於對門衛們生活做息的規律，選擇性地繞開他們的監視，另闢蹊徑溜進或者溜出大門，而後揚長而去，剩下守衛者一個孤獨的身影。

因此，我說泛型，並不神祕，也不神奇。