Java泛型的類型擦除怎么理解

今天小編給大家分享一下Java泛型的類型擦除怎么理解的相關(guān)知識點，內(nèi)容詳細(xì)，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

首先給大家奉上一道經(jīng)典的測試題。

List<String> l1 = new ArrayList<String>(); List<Integer> l2 = new ArrayList<Integer>(); System.out.println(l1.getClass() == l2.getClass());

請問，上面代碼最終結(jié)果輸出的是什么？不了解泛型的和很熟悉泛型的同學(xué)應(yīng)該能夠答出來，而對泛型有所了解，但是了解不深入的同學(xué)可能會答錯。

正確答案是 true。

上面的代碼中涉及到了泛型，而輸出的結(jié)果緣由是類型擦除。先好好說說泛型。

泛型是什么？

泛型的英文是 generics，generic 的意思是通用,而翻譯成中文，泛應(yīng)該意為廣泛，型是類型。所以泛型就是能廣泛適用的類型。

但泛型還有一種較為準(zhǔn)確的說法就是為了參數(shù)化類型，或者說可以將類型當(dāng)作參數(shù)傳遞給一個類或者是方法。

那么，如何解釋類型參數(shù)化呢？

public class Cache { Object value; public Object getValue() { return value; } public void setValue(Object value) { this.value = value; } }

假設(shè) Cache 能夠存取任何類型的值，于是，我們可以這樣使用它。

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

使用的方法也很簡單，只要我們做正確的強(qiáng)制轉(zhuǎn)換就好了。

但是，泛型卻給我們帶來了不一樣的編程體驗。

public class Cache<T> { T value; public Object getValue() { return value; } public void setValue(T value) { this.value = value; } }

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

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();

最顯而易見的好處就是它不再需要對取出來的結(jié)果進(jìn)行強(qiáng)制轉(zhuǎn)換了。但，還有另外一點不同。

泛型除了可以將類型參數(shù)化外，而參數(shù)一旦確定好，如果類似不匹配，編譯器就不通過。

上面代碼顯示，無法將一個 String 對象設(shè)置到 cache2 中，因為泛型讓它只接受 Integer 的類型。

所以，綜合上面信息，我們可以得到下面的結(jié)論。

與普通的 Object 代替一切類型這樣簡單粗暴而言，泛型使得數(shù)據(jù)的類別可以像參數(shù)一樣由外部傳遞進(jìn)來。它提供了一種擴(kuò)展能力。它更符合面向抽象開發(fā)的軟件編程宗旨。

當(dāng)具體的類型確定后，泛型又提供了一種類型檢測的機(jī)制，只有相匹配的數(shù)據(jù)才能正常的賦值，否則編譯器就不通過。所以說，它是一種類型安全檢測機(jī)制，一定程度上提高了軟件的安全性防止出現(xiàn)低級的失誤。

泛型提高了程序代碼的可讀性，不必要等到運行的時候才去強(qiáng)制轉(zhuǎn)換，在定義或者實例化階段，因為 Cache<String> 這個類型顯化的效果，程序員能夠一目了然猜測出代碼要操作的數(shù)據(jù)類型。

下面的文章，我們正常介紹泛型的相關(guān)知識。

泛型的定義和使用

泛型按照使用情況可以分為 3 種。

1. 泛型類。

2. 泛型方法。

3. 泛型接口。

泛型類

我們可以這樣定義一個泛型類。

public class Test<T> { T field1; }

尖括號 <> 中的 T 被稱作是類型參數(shù)，用于指代任何類型。事實上，T 只是一種習(xí)慣性寫法，如果你愿意。你可以這樣寫。

public class Test<Hello> { Hello field1; }

但出于規(guī)范的目的，Java 還是建議我們用單個大寫字母來代表類型參數(shù)。常見的如：

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<>();

只要在對泛型類創(chuàng)建實例的時候，在尖括號中賦值相應(yīng)的類型便是。T 就會被替換成對應(yīng)的類型，如 String 或者是 Integer。你可以相像一下，當(dāng)一個泛型類被創(chuàng)建時，內(nèi)部自動擴(kuò)展成下面的代碼。

public class Test<String> { String field1; }

當(dāng)然，泛型類不至接受一個類型參數(shù)，它還可以這樣接受多個類型參數(shù)。

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){ } }

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

當(dāng)然，聲明的類型參數(shù)，其實也是可以當(dāng)作返回值的類型的。

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

泛型類與泛型方法的共存現(xiàn)象

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 是一個泛型方法。而泛型類中的類型參數(shù)與泛型方法中的類型參數(shù)是沒有相應(yīng)的聯(lián)系的，泛型方法始終以自己定義的類型參數(shù)為準(zhǔn)。

所以，針對上面的代碼，我們可以這樣編寫測試代碼。

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

泛型類的實際類型參數(shù)是 String，而傳遞給泛型方法的類型參數(shù)是 Integer，兩者不想干。

但是，為了避免混淆，如果在一個泛型類中存在泛型方法，那么兩者的類型參數(shù)最好不要同名。比如，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> { }

通配符 ？

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

可能有同學(xué)會想，已經(jīng)有了 <T> 的形式了，為什么還要引進(jìn) <?> 這樣的概念呢？

class Base{} class Sub extends Base{} Sub sub = new Sub(); Base base = sub;

上面代碼顯示，Base 是 Sub 的父類，它們之間是繼承關(guān)系，所以 Sub 的實例可以給一個 Base 引用賦值，那么

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

最后一行代碼成立嗎？編譯會通過嗎？

答案是否定的。

編譯器不會讓它通過的。Sub 是 Base 的子類，不代表 List<Sub> 和 List<Base> 有繼承關(guān)系。

但是，在現(xiàn)實編碼中，確實有這樣的需求，希望泛型能夠處理某一范圍內(nèi)的數(shù)據(jù)類型，比如某個類和它的子類，對此 Java 引入了通配符這個概念。

所以，通配符的出現(xiàn)是為了指定泛型中的類型范圍。

通配符有 3 種形式。

<?> 被稱作無限定的通配符。

<? extends T> 被稱作有上限的通配符。

<? super T> 被稱作有下限的通配符。

無限定通配符

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

上面的代碼中，方法內(nèi)的參數(shù)是被無限定通配符修飾的 Collection 對象，它隱略地表達(dá)了一個意圖或者可以說是限定，那就是 testWidlCards() 這個方法內(nèi)部無需關(guān)注 Collection 中的真實類型，因為它是未知的。所以，你只能調(diào)用 Collection 中與類型無關(guān)的方法。

我們可以看到，當(dāng) <?> 存在時，Collection 對象喪失了 add() 方法的功能，編譯器不通過。

我們再看代碼。

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

有人說，<?> 提供了只讀的功能，也就是它刪減了增加具體類型元素的能力，只保留與具體類型無關(guān)的功能。它不管裝載在這個容器內(nèi)的元素是什么類型，它只關(guān)心元素的數(shù)量、容器是否為空？我想這種需求還是很常見的吧。

有同學(xué)可能會想，<?> 既然作用這么渺小，那么為什么還要引用它呢？

個人認(rèn)為，提高了代碼的可讀性，程序員看到這段代碼時，就能夠迅速對此建立極簡潔的印象，能夠快速推斷源碼作者的意圖。

<? extends T>

<?> 代表著類型未知，但是我們的確需要對于類型的描述再精確一點，我們希望在一個范圍內(nèi)確定類別，比如類型 A 及 類型 A 的子類都可以。

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

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

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

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

仍然編譯不通過。

沒有關(guān)系，我們不知道具體類型，但是我們至少清楚了類型的范圍。

<? super T>

這個和 <? extends T> 相對應(yīng)，代表 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());//編譯不通過 }

通配符與類型參數(shù)的區(qū)別

一般而言，通配符能干的事情都可以用類型參數(shù)替換。

比如

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

可以被

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

取代。

值得注意的是，如果用泛型方法來取代通配符，那么上面代碼中 collection 是能夠進(jìn)行寫操作的。只不過要進(jìn)行強(qiáng)制轉(zhuǎn)換。

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

需要特別注意的是，類型參數(shù)適用于參數(shù)之間的類別依賴關(guān)系，舉例說明。

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

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

E 類型是 T 類型的子類，顯然這種情況類型參數(shù)更適合。

有一種情況是，通配符和類型參數(shù)一起使用。

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

如果一個方法的返回類型依賴于參數(shù)的類型，那么通配符也無能為力。

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

類型擦除

泛型是 Java 1.5 版本才引進(jìn)的概念，在這之前是沒有泛型的概念的，但顯然，泛型代碼能夠很好地和之前版本的代碼很好地兼容。

這是因為，泛型信息只存在于代碼編譯階段，在進(jìn)入 JVM 之前，與泛型相關(guān)的信息會被擦除掉，專業(yè)術(shù)語叫做類型擦除。

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

List<String> l1 = new ArrayList<String>(); List<Integer> l2 = new ArrayList<Integer>(); System.out.println(l1.getClass() == l2.getClass());

打印的結(jié)果為 true 是因為 List<String> 和 List<Integer> 在 jvm 中的 Class 都是 List.class。

泛型信息被擦除了。

可能同學(xué)會問，那么類型 String 和 Integer 怎么辦？

答案是泛型轉(zhuǎn)譯。

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

Erasure 是一個泛型類，我們查看它在運行時的狀態(tài)信息可以通過反射。

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

打印的結(jié)果是

erasure class is:com.frank.test.Erasure

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()); }

打印結(jié)果是

Field name object type:java.lang.Object

那我們可不可以說，泛型類被類型擦除后，相應(yīng)的類型就被替換成 Object 類型呢？

這種說法，不完全正確。

我們更改一下代碼。

public class Erasure <T extends String>{ // public class Erasure <T>{ T object; public Erasure(T object) { this.object = object; } }

現(xiàn)在再看測試結(jié)果：

Field name object type:java.lang.String

我們現(xiàn)在可以下結(jié)論了，在泛型類被類型擦除的時候，之前泛型類中的類型參數(shù)部分如果沒有指定上限，如 <T> 則會被轉(zhuǎn)譯成普通的 Object 類型，如果指定了上限如 <T extends String> 則類型參數(shù)就被替換成類型上限。

所以，在反射中。

public class Erasure <T>{ T object; public Erasure(T object) { this.object = object; } public void add(T object){ } }

add() 這個方法對應(yīng)的 Method 的簽名應(yīng)該是 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()); }

打印結(jié)果是

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

也就是說，如果你要在反射中找到 add 對應(yīng)的 Method，你應(yīng)該調(diào)用 getDeclaredMethod("add",Object.class) 否則程序會報錯，提示沒有這么一個方法，原因就是類型擦除的時候，T 被替換成 Object 類型了。

類型擦除帶來的局限性

類型擦除，是泛型能夠與之前的 java 版本代碼兼容共存的原因。但也因為類型擦除，它會抹掉很多繼承相關(guān)的特性，這是它帶來的局限性。

理解類型擦除有利于我們繞過開發(fā)當(dāng)中可能遇到的雷區(qū)，同樣理解類型擦除也能讓我們繞過泛型本身的一些限制。比如

正常情況下，因為泛型的限制，編譯器不讓最后一行代碼編譯通過，因為類似不匹配，但是，基于對類型擦除的了解，利用反射，我們可以繞過這個限制。

public interface List<E> extends Collection<E>{ boolean add(E e); }

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

因為 E 代表任意的類型，所以類型擦除時，add 方法其實等同于

boolean add(Object obj);

那么，利用反射，我們繞過編譯器去調(diào)用 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); } } }

打印結(jié)果是：

23 test 42.9

可以看到，利用類型擦除的原理，用反射的手段就繞過了正常開發(fā)中編譯器不允許的操作限制。

泛型中值得注意的地方

泛型類或者泛型方法中，不接受 8 種基本數(shù)據(jù)類型。

所以，你沒有辦法進(jìn)行這樣的編碼。

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

需要使用它們對應(yīng)的包裝類。

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

對泛型方法的困惑

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

有的同學(xué)可能對于連續(xù)的兩個 T 感到困惑，其實 <T> 是為了說明類型參數(shù)，是聲明,而后面的不帶尖括號的 T 是方法的返回值類型。

你可以相像一下，如果 test() 這樣被調(diào)用

test("123");

那么實際上相當(dāng)于

public String test(String t);

Java 不能創(chuàng)建具體類型的泛型數(shù)組

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

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

這兩行代碼是無法在編譯器中編譯通過的。原因還是類型擦除帶來的影響。

List<Integer> 和 List<Boolean> 在 jvm 中等同于List<Object> ，所有的類型信息都被擦除，程序也無法分辨一個數(shù)組中的元素類型具體是 List<Integer>類型還是 List<Boolean> 類型。

但是，

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

借助于無限定通配符卻可以，前面講過 ？ 代表未知類型，所以它涉及的操作都基本上與類型無關(guān)，因此 jvm 不需要針對它對類型作判斷，因此它能編譯通過，但是，只提供了數(shù)組中的元素因為通配符原因，它只能讀，不能寫。比如，上面的 v 這個局部變量，它只能進(jìn)行 get() 操作，不能進(jìn)行 add() 操作，這個在前面通配符的內(nèi)容小節(jié)中已經(jīng)講過。

泛型，并不神奇

我們可以看到，泛型其實并沒有什么神奇的地方，泛型代碼能做的非泛型代碼也能做。

而類型擦除，是泛型能夠與之前的 java 版本代碼兼容共存的原因。

可量也正因為類型擦除導(dǎo)致了一些隱患與局限。

但，我還是要建議大家使用泛型，如官方文檔所說的，如果可以使用泛型的地方，盡量使用泛型。

畢竟它抽離了數(shù)據(jù)類型與代碼邏輯，本意是提高程序代碼的簡潔性和可讀性，并提供可能的編譯時類型轉(zhuǎn)換安全檢測功能。

類型擦除不是泛型的全部，但是它卻能很好地檢測我們對于泛型這個概念的理解程度。

以上就是“Java泛型的類型擦除怎么理解”這篇文章的所有內(nèi)容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學(xué)習(xí)更多的知識，請關(guān)注億速云行業(yè)資訊頻道。