簡單理解java泛型的本質(zhì)（非類型擦除）

更新時間：2019年05月24日 10:01:59 作者：彤哥讀源碼

泛型在java中有很重要的地位，在面向?qū)ο缶幊碳案鞣N設(shè)計模式中有非常廣泛的應(yīng)用。泛型是參數(shù)化類型的應(yīng)用，操作的數(shù)據(jù)類型不限定于特定類型，可以根據(jù)實際需要設(shè)置不同的數(shù)據(jù)類型，以實現(xiàn)代碼復(fù)用。下面小編來簡單講一講泛型

背景

之前在網(wǎng)上發(fā)現(xiàn)這個問題

public class GenericTest {
 //方法一
 public static <T extends Comparable<T>> List<T> sort(List<T> list) {
 return Arrays.asList(list.toArray((T[]) new Comparable[list.size()]));
 }
 //方法二
 public static <T extends Comparable<T>> T[] sort2(List<T> list) {
 // 這里沒報錯
 return list.toArray((T[]) new Comparable[list.size()]);
 }
 public static void main(String[] args) {
 List<Integer> list = new ArrayList<>();
 list.add(1);
 list.add(2);
 // 方法一調(diào)用正常
 System.out.println(sort(list).getClass());
 // 方法二調(diào)用報錯了，這里報錯了
 System.out.println(sort2(list).getClass());
 }
}

這個問題有以下四個現(xiàn)象：

（1）方法一調(diào)用完全正常；

（2）方法二調(diào)用報錯了；

（3）方法二報錯的地方是在System.out.println(sort2(list).getClass());這行，而不是return list.toArray((T[]) new Comparable[list.size()]);這行；

（4）報的錯是[Ljava.lang.Comparable; cannot be cast to [Ljava.lang.Integer;；

怎么樣？你心中有答案嘛？類型擦除？怎么擦？摩擦摩擦？

解決

剛拿到這道題，我也是一臉懵逼，這要報錯也應(yīng)該是在return list.toArray((T[]) new Comparable[list.size()]);這行啊，而且要報錯應(yīng)該兩個方法都報錯啊。

抱著不放棄不拋棄的心態(tài)，彤哥做了大量的實驗，終于得出了泛型的本質(zhì)，且聽我娓娓道來。

小插曲

首先，我們要明白，java中的數(shù)組是不支持向下轉(zhuǎn)型的，但是如果本身就是那個類型的是可以轉(zhuǎn)過去的，請看下面的例子：

public static void main(String[] args) {
 Object[] objs = new Object[]{1};
 // 類型轉(zhuǎn)換錯誤
// Integer[] ins = (Integer[]) objs;
 Object[] objs2 = new Integer[]{1};
 // 不報錯
 Integer[] ins2 = (Integer[]) objs2;

}

java里的泛型是假泛型，只在編譯期有效，在運行時是沒有泛型的概念的，舉個簡單的例子：

public static void main(String[] args) {
 List<String> strList = Arrays.asList("1");
 List<Integer> intList = Arrays.asList(1);
 // 打?。簍rue
 System.out.println(strList.getClass() == intList.getClass());
 }

可以看到兩個list的類型是一樣的，如果你覺得這個例子不夠說服力，那我給你個過分點的例子：

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
 List<String> strList = new ArrayList<>();
 Method addMethod = strList.getClass().getMethod("add", Object.class);
 addMethod.invoke(strList, 1);
 addMethod.invoke(strList, true);
 addMethod.invoke(strList, new Long(1));
 addMethod.invoke(strList, new Byte[]{1});

 // 打印：[1, true, 1, 1]
 System.out.println(strList);
}

瞧，我可以往一個String類型的List中扔任何我想扔的東西，服不服？！

所以說java里面的泛型是假的，運行時不存在滴。

回歸正題

數(shù)組不能向下強轉(zhuǎn)我懂了，類型擦除我也懂了，似乎還是過不好這一生，呃不是，是還是解決不了這道題??？

呃，好像是~~

我們再來看一個簡單的例子：

// GenericTest2.java（源碼）
public class GenericTest2 {
 public static void main(String[] args) {
 System.out.println(raw("1"));
 }
 public static <T> T raw(T t) {
 return t;
 }
}
// GenericTest2.class（反編譯）
public class GenericTest2 {
 public GenericTest2() {
 }
 public static void main(String[] args) {
 System.out.println((String)raw("1"));
 }
 public static <T> T raw(T t) {
 return t;
 }
}

嗯~似乎看出來點端倪，反編譯后多了個構(gòu)造方法。

呃，沒錯。還有呢？

仔細一看，System.out.println((String)raw("1"));這一句多加了個String強轉(zhuǎn)。

這就是關(guān)鍵所在，結(jié)合類型擦除，運行時并沒有所謂的泛型，所以raw()返回的其實是Object，但是調(diào)用者自己知道我要的是String類型啊，所以我就知道強轉(zhuǎn)一下嘍。

我們再來看個極端的例子：

// GenericTest2.java（源碼）
public class GenericTest2 {
 public static void main(String[] args) {
 System.out.println(raw("1"));
 }
 public static <T> T raw(T t) {
 return (T)new Integer(1);
 }
}
// GenericTest2.class（反編譯）
public class GenericTest2 {
 public GenericTest2() {
 }
 public static void main(String[] args) {
 System.out.println((String)raw("1"));
 }
 public static <T> T raw(T t) {
 return new Integer(1);
 }
}

仔細觀察，可以發(fā)現(xiàn)，raw()方法里的強轉(zhuǎn)(T)new Integer(1)變成了new Integer(1)，強轉(zhuǎn)被擦除了，實際上在運行時這里的T變成了Object，所有類型都是Object的子類，也就不需要強轉(zhuǎn)了。

而(String)raw("1")的強轉(zhuǎn)還是加上的，這是調(diào)用者知道類型是String，所以raw()返回后自己強轉(zhuǎn)成String一下。

當然，這個代碼運行是會報錯的，java.lang.Integer cannot be cast to java.lang.String，因為raw()返回的是Integer類型，強轉(zhuǎn)成String類型失敗了。

好了，基本思路就是這樣。

泛型類呢？

我們上面舉的例子都是泛型方法，那么泛型類呢？

同樣地，我們來看個例子：

// GenericTest3.java（源碼）
public class GenericTest3 {
 public static void main(String[] args) {
 System.out.println(new Raw<String>().raw("1"));
 }
}
class Raw<T> {
 public T raw(T t) {
 return (T)new Integer(1);
 }
}
// GenericTest3.class（反編譯）
public class GenericTest3 {
 public GenericTest3() {
 }
 public static void main(String[] args) {
 System.out.println((String)(new Raw()).raw("1"));
 }
}
class Raw<T> {
 Raw() {
 }
 public T raw(T t) {
 return new Integer(1);
 }
}

可以看到，跟泛型方法的表現(xiàn)一模一樣。當然，這里運行時也會報java.lang.Integer cannot be cast to java.lang.String這個錯誤。

總結(jié)

java中的泛型只在編譯期有效，在運行時只有調(diào)用者知道需要什么類型，且調(diào)用者調(diào)用泛型方法后自己做強制轉(zhuǎn)換，被調(diào)用者是完全無感的。

所以，出現(xiàn)問題不要問被調(diào)用者，而是要問調(diào)用者，你丫是怎么調(diào)用的？！

解答開篇

為了方便我們還是把開篇的問題拿過來。

// GenericTest.java（源碼）
public class GenericTest {
 //方法一
 public static <T extends Comparable<T>> List<T> sort(List<T> list) {
 return Arrays.asList(list.toArray((T[]) new Comparable[list.size()]));
 }
 //方法二
 public static <T extends Comparable<T>> T[] sort2(List<T> list) {
 // 這里沒報錯
 return list.toArray((T[]) new Comparable[list.size()]);
 }
 public static void main(String[] args) {
 List<Integer> list = new ArrayList<>();
 list.add(1);
 list.add(2);
 // 方法一調(diào)用正常
 System.out.println(sort(list).getClass());
 // 方法二調(diào)用報錯了，這里報錯了
 System.out.println(sort2(list).getClass());
 }
}

這里似乎又不太一樣，變成了<T extends Comparable<T>>，其實是一樣的啦，如果單獨寫<T>是相當于<T extends Object>的。

那么，我們就延伸一下，被調(diào)用者是完全無感的，它只能盡力拿到它知道的類型，比如這里就只能盡力拿到Comparable，如果是<T>拿到的就是Object。

所以，方法二返回的就是實打?qū)嵉腃omparable[]類型，作為被調(diào)用者，它一點問題都沒有。

但是，調(diào)用方是知道我需要的是Integer[]類型的，因為list里面是Integer類型，所以返回的應(yīng)該是Integer[]類型，所以我就強轉(zhuǎn)嘍，然后就報錯了。

到底是不是這樣？我們來看看反編譯后的代碼：

// GenericTest.class（反編譯）
public class GenericTest {
 public GenericTest() {
 }
 public static <T extends Comparable<T>> List<T> sort(List<T> list) {
 return Arrays.asList(list.toArray((Comparable[])(new Comparable[list.size()])));
 }
 public static <T extends Comparable<T>> T[] sort2(List<T> list) {
 // 這里使用的是Comparable[]強轉(zhuǎn)，所以返回的也是實打?qū)嵉腃omparable[]類型
 return (Comparable[])list.toArray((Comparable[])(new Comparable[list.size()]));
 }
 public static void main(String[] args) {
 List<Integer> list = new ArrayList();
 list.add(1);
 list.add(2);
 System.out.println(sort(list).getClass());
 // 數(shù)組向下轉(zhuǎn)型失敗
 System.out.println(((Integer[])sort2(list)).getClass());
 }
}

可以看到，跟我們的分析完全一致。

java中的泛型只在編譯期有效，在運行時只有調(diào)用者知道它自己需要什么類型，且調(diào)用者調(diào)用泛型方法后自己做強制轉(zhuǎn)換，被調(diào)用者是完全無感的，被調(diào)用者只能盡力拿到它所知道的類型。

此時，我的腦海中不經(jīng)響起那熟悉的旋律，“一句話，一輩子……”，今天的這句話你記住了嗎？

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: