前言

泛型，一個(gè)孤獨(dú)的守門(mén)者。

大家可能會(huì)有疑問(wèn)，我為什么叫做泛型是一個(gè)守門(mén)者。這其實(shí)是我個(gè)人的看法而已，我的意思是說(shuō)泛型沒(méi)有其看起來(lái)那么深不可測(cè)，它并不神秘與神奇。泛型是 Java 中一個(gè)很小巧的概念，但同時(shí)也是一個(gè)很容易讓人迷惑的知識(shí)點(diǎn)，它讓人迷惑的地方在于它的許多表現(xiàn)有點(diǎn)違反直覺(jué)。

文章開(kāi)始的地方，先給大家奉上一道經(jīng)典的測(cè)試題。

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

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

正確答案是 true。

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

泛型是什么？

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

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

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

public class Cache {
	Object value;
	public Object getValue() {
		return value;
	}

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

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

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

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

但是，泛型卻給我們帶來(lái)了不一樣的編程體驗(yàn)。

public class Cache<T> {
	T value;
	public Object getValue() {
		return value;
	}

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

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

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àn)的好處就是它不再需要對(duì)取出來(lái)的結(jié)果進(jìn)行強(qiáng)制轉(zhuǎn)換了。但，還有另外一點(diǎn)不同。

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

上面代碼顯示，無(wú)法將一個(gè) String 對(duì)象設(shè)置到 cache2 中，因?yàn)榉盒妥屗唤邮?Integer 的類(lèi)型。

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

1. 與普通的 Object 代替一切類(lèi)型這樣簡(jiǎn)單粗暴而言，泛型使得數(shù)據(jù)的類(lèi)別可以像參數(shù)一樣由外部傳遞進(jìn)來(lái)。它提供了一種擴(kuò)展能力。它更符合面向抽象開(kāi)發(fā)的軟件編程宗旨。
2. 當(dāng)具體的類(lèi)型確定后，泛型又提供了一種類(lèi)型檢測(cè)的機(jī)制，只有相匹配的數(shù)據(jù)才能正常的賦值，否則編譯器就不通過(guò)。所以說(shuō)，它是一種類(lèi)型安全檢測(cè)機(jī)制，一定程度上提高了軟件的安全性防止出現(xiàn)低級(jí)的失誤。
3. 泛型提高了程序代碼的可讀性，不必要等到運(yùn)行的時(shí)候才去強(qiáng)制轉(zhuǎn)換，在定義或者實(shí)例化階段，因?yàn)?Cache<String>這個(gè)類(lèi)型顯化的效果，程序員能夠一目了然猜測(cè)出代碼要操作的數(shù)據(jù)類(lèi)型。

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

泛型的定義和使用

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

1. 泛型類(lèi)。
2. 泛型方法。
3. 泛型接口。

泛型類(lèi)

我們可以這樣定義一個(gè)泛型類(lèi)。

public class Test<T> {
	T field1;
}

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

public class Test<Hello> {
	Hello field1;
}

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

1. T 代表一般的任何類(lèi)。
2. E 代表 Element 的意思，或者 Exception 異常的意思。
3. K 代表 Key 的意思。
4. V 代表 Value 的意思，通常與 K 一起配合使用。
5. S 代表 Subtype 的意思，文章后面部分會(huì)講解示意。

如果一個(gè)類(lèi)被 <T>的形式定義，那么它就被稱(chēng)為是泛型類(lèi)。

那么對(duì)于泛型類(lèi)怎么樣使用呢？

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

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

public class Test<String> {
	String field1;
}

當(dāng)然，泛型類(lèi)不至接受一個(gè)類(lèi)型參數(shù)，它還可以這樣接受多個(gè)類(lèi)型參數(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){
	}
}

泛型方法與泛型類(lèi)稍有不同的地方是，類(lèi)型參數(shù)也就是尖括號(hào)那一部分是寫(xiě)在返回值前面的。<T>中的 T 被稱(chēng)為類(lèi)型參數(shù)，而方法中的 T 被稱(chēng)為參數(shù)化類(lèi)型，它不是運(yùn)行時(shí)真正的參數(shù)。

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

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

泛型類(lèi)與泛型方法的共存現(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>是泛型類(lèi)，testMethod 是泛型類(lèi)中的普通方法，而 testMethod1 是一個(gè)泛型方法。而泛型類(lèi)中的類(lèi)型參數(shù)與泛型方法中的類(lèi)型參數(shù)是沒(méi)有相應(yīng)的聯(lián)系的，泛型方法始終以自己定義的類(lèi)型參數(shù)為準(zhǔn)。

所以，針對(duì)上面的代碼，我們可以這樣編寫(xiě)測(cè)試代碼。

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

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

但是，為了避免混淆，如果在一個(gè)泛型類(lèi)中存在泛型方法，那么兩者的類(lèi)型參數(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;
	}
}

泛型接口

泛型接口和泛型類(lèi)差不多，所以一筆帶過(guò)。

public interface Iterable<T> {
}

通配符 ？

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

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

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

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

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

最后一行代碼成立嗎？編譯會(huì)通過(guò)嗎？

答案是否定的。

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

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

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

通配符有 3 種形式。

1. <?>被稱(chēng)作無(wú)限定的通配符。
2. <? extends T>被稱(chēng)作有上限的通配符。
3. <? super T>被稱(chēng)作有下限的通配符。

無(wú)限定通配符 <?>

無(wú)限定通配符經(jīng)常與容器類(lèi)配合使用，它其中的 ? 其實(shí)代表的是未知類(lèi)型，所以涉及到 ? 時(shí)的操作，一定與具體類(lèi)型無(wú)關(guān)。

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

上面的代碼中，方法內(nèi)的參數(shù)是被無(wú)限定通配符修飾的 Collection 對(duì)象，它隱略地表達(dá)了一個(gè)意圖或者可以說(shuō)是限定，那就是 testWidlCards() 這個(gè)方法內(nèi)部無(wú)需關(guān)注 Collection 中的真實(shí)類(lèi)型，因?yàn)樗俏粗?/strong>。所以，你只能調(diào)用 Collection 中與類(lèi)型無(wú)關(guān)的方法。

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

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

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

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

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

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

public <T> void test(Collection<T> 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){
	}

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

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

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

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

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

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

泛型信息被擦除了。

可能同學(xué)會(huì)問(wèn)，那么類(lèi)型 String 和 Integer 怎么辦？

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

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

Erasure 是一個(gè)泛型類(lèi)，我們查看它在運(yùn)行時(shí)的狀態(tài)信息可以通過(guò)反射。

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 的類(lèi)型仍然是 Erasure 并不是 Erasure<T>這種形式，那我們?cè)倏纯捶盒皖?lèi)中 T 的類(lèi)型在 jvm 中是什么具體類(lèi)型。

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

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

這種說(shuō)法，不完全正確。

我們更改一下代碼。

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

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

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

Field name object type:java.lang.String

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

所以，在反射中。

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

add() 這個(gè)方法對(duì)應(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)

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

類(lèi)型擦除帶來(lái)的局限性

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

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

正常情況下，因?yàn)榉盒偷南拗?，編譯器不讓最后一行代碼編譯通過(guò)，因?yàn)轭?lèi)似不匹配，但是，基于對(duì)類(lèi)型擦除的了解，利用反射，我們可以繞過(guò)這個(gè)限制。

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

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

因?yàn)?E 代表任意的類(lèi)型，所以類(lèi)型擦除時(shí)，add 方法其實(shí)等同于

boolean add(Object obj);

那么，利用反射，我們繞過(guò)編譯器去調(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

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

泛型中值得注意的地方

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

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

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

需要使用它們對(duì)應(yīng)的包裝類(lèi)。

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

對(duì)泛型方法的困惑

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

有的同學(xué)可能對(duì)于連續(xù)的兩個(gè) T 感到困惑，其實(shí) <T>是為了說(shuō)明類(lèi)型參數(shù)，是聲明,而后面的不帶尖括號(hào)的 T 是方法的返回值類(lèi)型。
你可以相像一下，如果 test() 這樣被調(diào)用

test("123");

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

public String test(String t);

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

這句話(huà)可能難以理解，代碼說(shuō)明。

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

這兩行代碼是無(wú)法在編譯器中編譯通過(guò)的。原因還是類(lèi)型擦除帶來(lái)的影響。

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

但是，

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

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

泛型，并不神奇

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

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

可量也正因?yàn)轭?lèi)型擦除導(dǎo)致了一些隱患與局限。

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

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

類(lèi)型擦除不是泛型的全部，但是它卻能很好地檢測(cè)我們對(duì)于泛型這個(gè)概念的理解程度。

我在文章開(kāi)頭將泛型比作是一個(gè)守門(mén)人，原因就是他本意是好的，守護(hù)我們的代碼安全，然后在門(mén)牌上寫(xiě)著出入的各項(xiàng)規(guī)定，及“xxx 禁止出入”的提醒。但是同我們?nèi)粘Ｋ龅降哪切╅T(mén)衛(wèi)一般，他們古怪偏執(zhí)，死板守舊，我們可以利用反射基于類(lèi)型擦除的認(rèn)識(shí)，來(lái)繞過(guò)泛型中某些限制，現(xiàn)實(shí)生活中，也總會(huì)有調(diào)皮搗蛋者能夠基于對(duì)門(mén)衛(wèi)們生活作息的規(guī)律，選擇性地繞開(kāi)他們的監(jiān)視，另辟蹊徑溜進(jìn)或者溜出大門(mén)，然后揚(yáng)長(zhǎng)而去，剩下守衛(wèi)者一個(gè)孤獨(dú)的身影。

所以，我說(shuō)泛型，并不神秘，也不神奇。

總結(jié)

到此這篇關(guān)于Java泛型之類(lèi)型擦除的文章就介紹到這了,更多相關(guān)Java泛型類(lèi)型擦除內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論