使用Java的小伙伴，對(duì)于Java的一些高級(jí)特性一定再熟悉不過(guò)了，例如集合、反射、泛型、注解等等，這些可以說(shuō)我們?cè)谄綍r(shí)開(kāi)發(fā)中是經(jīng)常使用到的，尤其是集合，基本是只要寫(xiě)代碼沒(méi)有用不到的，今天我們先來(lái)談?wù)?/span>泛型。

1. 定義

在了解一個(gè)事物之前，我們必定要先知道他的定義，所以我們就從定義開(kāi)始，去一步一步揭開(kāi)泛型的神秘面紗。

# 泛型（generics）  他是 JDK5 中引入的一個(gè)新特性，泛型提供了編譯時(shí)類(lèi)型安全監(jiān)測(cè)機(jī)制，該機(jī)制允許我們?cè)诰幾g時(shí)檢測(cè)到非法的類(lèi)型數(shù)據(jù)結(jié)構(gòu)。泛型的本質(zhì)就是參數(shù)化類(lèi)型，也就是所操作的數(shù)據(jù)類(lèi)型被指定為一個(gè)參數(shù)   # 常見(jiàn)的泛型的類(lèi)型表示 上面的 T 僅僅類(lèi)似一個(gè)形參的作用，名字實(shí)際上是可以任意起的，但是我們寫(xiě)代碼總該是要講究可讀性的。常見(jiàn)的參數(shù)通常有 :  E - Element (在集合中使用，因?yàn)榧现写娣诺氖窃?  T - Type（表示Java 類(lèi)，包括基本的類(lèi)和我們自定義的類(lèi)）  K - Key（表示鍵，比如Map中的key）  V - Value（表示值）  ? - （表示不確定的java類(lèi)型） 但是泛型的參數(shù)只能是類(lèi)類(lèi)型，不能是基本的數(shù)據(jù)類(lèi)型，他的類(lèi)型一定是自O(shè)bject的

注意：泛型不接受基本數(shù)據(jù)類(lèi)型，換句話(huà)說(shuō)，只有引用類(lèi)型才能作為泛型方法的實(shí)際參數(shù)

2. 為什么要使用泛型？

說(shuō)到為什么要使用，那肯定是找一大堆能說(shuō)服自己的優(yōu)點(diǎn)啊。

# 泛型的引入，是java語(yǔ)言的來(lái)講是一個(gè)較大的功能增強(qiáng)。同時(shí)對(duì)于編譯器也帶來(lái)了一定的增強(qiáng)，為了支持泛型，java的類(lèi)庫(kù)都做相應(yīng)的修改以支持泛型的特性。 （科普：實(shí)際上java泛型并不是 jdk5（2004發(fā)布了jdk5） 才提出來(lái)的，早在1999年的時(shí)候，泛型機(jī)制就是java最早的規(guī)范之一）

另外，泛型還具有以下的優(yōu)點(diǎn)：

# 1.提交了java的類(lèi)型安全  泛型在很大程度上來(lái)提高了java的程序安全。例如在沒(méi)有泛型的情況下，很容易將字符串 123 轉(zhuǎn)成 Integer 類(lèi)型的 123 亦或者 Integer 轉(zhuǎn)成 String，而這樣的錯(cuò)誤是在編譯期無(wú)法檢測(cè)。而使用泛型，則能很好的避免這樣的情況發(fā)生。  # 2.不需要煩人的強(qiáng)制類(lèi)型轉(zhuǎn)換  泛型之所以能夠消除強(qiáng)制類(lèi)型轉(zhuǎn)換，那是因?yàn)槌绦騿T在開(kāi)發(fā)的時(shí)候就已經(jīng)明確了自己使用的具體類(lèi)型，這不但提高了代碼的可讀性，同樣增加了代碼的健壯性。   # 提高了代碼的重用性  泛型的程序設(shè)計(jì)，意味著編寫(xiě)的代碼可以被很多不同類(lèi)型的對(duì)象所重用

在泛型規(guī)范正式發(fā)布之前，泛型的程序設(shè)計(jì)是通過(guò)繼承來(lái)實(shí)現(xiàn)的，但是這樣子有兩個(gè)嚴(yán)重的問(wèn)題：

① 取值的時(shí)候需要強(qiáng)制類(lèi)型轉(zhuǎn)換，否則拿到的都是 Object

② 編譯期不會(huì)有錯(cuò)誤檢查

我們來(lái)看下這兩個(gè)錯(cuò)誤的產(chǎn)生

2.1 編譯期不會(huì)有錯(cuò)誤檢查

public class DonCheckInCompile {  public static void main(String[] args) {  List list = new ArrayList();  list.add("a");  list.add(3);  System.out.println(list);  } }

程序不但不會(huì)報(bào)錯(cuò)，還能正常輸出

2.2 強(qiáng)制類(lèi)型轉(zhuǎn)換

public class DonCheckInCompile {  public static void main(String[] args) {  List list = new ArrayList();  list.add("a");  list.add(3);  for (Object o : list) {  System.out.println((String)o);  }  } }

因?yàn)槟悴⒉恢缹?shí)際集合中的元素到底是哪些類(lèi)型的，所以在使用的時(shí)候也是不確定的，如果在強(qiáng)轉(zhuǎn)的時(shí)候，那必然會(huì)帶來(lái)意想不到的錯(cuò)誤，這樣潛在的問(wèn)題就好像是定時(shí)炸彈，肯定是不允許發(fā)生的。所以這就更體現(xiàn)了泛型的重要性。

3. 泛型方法

在 java 中，泛型方法可以使用在成員方法、構(gòu)造方法和靜態(tài)方法中。語(yǔ)法如下：

public <申明泛型的類(lèi)型> 類(lèi)型參數(shù) fun()；如 public T fun(T t)；這里的 T 表示一個(gè)泛型類(lèi)型，而 表示我們定義了一個(gè)類(lèi)型為 T 的類(lèi)型，這樣的 T 類(lèi)型就可以直接使用了，且 需要放在方法的返回值類(lèi)型之前。T 即在申明的時(shí)候是不知道具體的類(lèi)型的，只有的使用的時(shí)候才能明確其類(lèi)型，T 不是一個(gè)類(lèi)，但是可以當(dāng)作是一種類(lèi)型來(lái)使用。

下面來(lái)通過(guò)具體的例子來(lái)解釋說(shuō)明，以下代碼將數(shù)組中的指定的兩個(gè)下標(biāo)位置的元素進(jìn)行交換（不要去關(guān)注實(shí)際的需求是什么），第一種 Integer 類(lèi)型的數(shù)組

public class WildcardCharacter {  public static void main(String[] args) {  Integer[] arrInt = {1, 2, 3, 4, 5, 6, 7, 8, 9};  change(arrInt, 0, 8);  System.out.println("arr = " + Arrays.asList(arrInt));  }   /**  * 將數(shù)組中的指定兩個(gè)下標(biāo)位置的元素交換  *  * @param arr         數(shù)組  * @param firstIndex 第一個(gè)下標(biāo)  * @param secondIndex 第二個(gè)下標(biāo)  */  private static void change(Integer[] arr, int firstIndex, int secondIndex) {  int tmp = arr[firstIndex];  arr[firstIndex] = arr[secondIndex];  arr[secondIndex] = tmp;  } }

第二種是 String 類(lèi)型的數(shù)組

編譯直接都不會(huì)通過(guò)，那是必然的，因?yàn)榉椒ǘx的參數(shù)就是 Integer[] 結(jié)果你傳一個(gè) String[]，玩呢。。。所以這個(gè)時(shí)候只能是再定義一個(gè)參數(shù)類(lèi)型是 String[]的。

那要是再來(lái)一個(gè) Double 呢？Boolean 呢？是不是這就產(chǎn)生問(wèn)題了，雖然說(shuō)這種問(wèn)題不是致命的，多寫(xiě)一些重復(fù)的代碼就能解決，但這勢(shì)必導(dǎo)致代碼的冗余和維護(hù)成本的增加。所以這個(gè)時(shí)候泛型的作用就體現(xiàn)了，我們將其改成泛型的方式。

 /**  * @param t           參數(shù)類(lèi)型 T  * @param firstIndex 第一個(gè)下標(biāo)  * @param secondIndex 第二個(gè)下標(biāo)  * @param表示定義了一個(gè)類(lèi)型 為 T 的類(lèi)型，否則沒(méi)人知道 T 是什么，編譯期也不知道  */  private static <T> void changeT(T[] t, int firstIndex, int secondIndex) {  T tmp = t[firstIndex];  t[firstIndex] = t[secondIndex];  t[secondIndex] = tmp;  }

接下來(lái)調(diào)用就簡(jiǎn)單了

 public static void main(String[] args) {   //首先定義一個(gè)Integer類(lèi)型的數(shù)組  Integer[] arrInt = {1, 2, 3, 4, 5, 6, 7, 8, 9};   //將第 1 個(gè)和第 9 個(gè)位置的元素進(jìn)行交換  changeT(arrInt, 0, 8);  System.out.println("arrInt = " + Arrays.asList(arrInt));  // 然后在定義一個(gè)String類(lèi)型的數(shù)組  String[] arrStr = {"a", "b", "c", "d", "e", "f", "g"};   //將第 1 個(gè)和第 2 個(gè)位置的元素進(jìn)行交換  changeT(arrStr, 0, 1);  System.out.println("arrStr = " + Arrays.asList(arrStr));  }

問(wèn)題迎刃而解，至于普通的泛型方法和靜態(tài)的泛型方法是一樣的使用，只不過(guò)是一個(gè)數(shù)據(jù)類(lèi)一個(gè)屬于類(lèi)的實(shí)例的，在使用上區(qū)別不大（但是需要注意的是如果在泛型類(lèi)中 靜態(tài)泛型方法是不能使用類(lèi)泛型中的泛型類(lèi)型的，這個(gè)在下文的泛型類(lèi)中會(huì)詳細(xì)介紹的）。

最后在來(lái)看下構(gòu)造方法

public class Father {
    publicFather(T t) {
    }
}

然后假設(shè)他有一個(gè)子類(lèi)是這樣子的

class Son extends Father {

    publicSon(T t) {
        super(t);
    }
}

這里強(qiáng)調(diào)一下，因?yàn)樵?Father 類(lèi)中是沒(méi)有無(wú)參構(gòu)造器的，取而代之的是一個(gè)有參的構(gòu)造器，只不過(guò)這個(gè)構(gòu)造方法是一個(gè)泛型的方法，那這樣子的子類(lèi)必然需要顯示的指明構(gòu)造器了。

• 通過(guò)泛型方法獲取集合中的元素測(cè)試

既然說(shuō)泛型是在申明的時(shí)候類(lèi)型不是重點(diǎn)，只要事情用的時(shí)候確定就可以下，那你看下面這個(gè)怎么解釋?zhuān)?/span>

此時(shí)想往集合中添加元素，卻提示這樣的錯(cuò)誤，連編譯都過(guò)不了。這是為什么？

因?yàn)榇藭r(shí)集合 List 的 add 方法，添加的類(lèi)型為 T，但是很顯然 T 是一個(gè)泛型，真正的類(lèi)型是在使用時(shí)候才能確定的，但是 在 add 的并不能確定 T 的類(lèi)型，所以根本就無(wú)法使用 add 方法，除非 list.add(null)，但是這卻沒(méi)有任何意義。

4. 泛型類(lèi)

先來(lái)看一段這樣的代碼，里面的使用到了多個(gè)泛型的方法，無(wú)需關(guān)注方法到底做了什么

public class GenericClassTest{
    public static void main(String[] args) {
        //首先定義一個(gè)Integer類(lèi)型的數(shù)組
        Integer[] arrInt = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        //將第 1 個(gè)和第 9 個(gè)位置的元素進(jìn)行交換

       new GenericClassTest().changeT(arrInt, 0, 8);
        System.out.println("arrInt = " + Arrays.asList(arrInt));

        Listlist = Arrays.asList("a", "b");
        testIter(list);
    }

    /**
     * @param t           參數(shù)類(lèi)型 T
     * @param firstIndex  第一個(gè)下標(biāo)
     * @param secondIndex 第二個(gè)下標(biāo)
     * @param表示定義了一個(gè)類(lèi)型 為 T 的類(lèi)型，否則沒(méi)人知道 T 是什么，編譯期也不知道
     */
    privatevoid changeT(T[] t, int firstIndex, int secondIndex) {
        T tmp = t[firstIndex];
        t[firstIndex] = t[secondIndex];
        t[secondIndex] = tmp;
    }

    /**
     * 遍歷集合
     *
     * @param list 集合
     * @param表示定義了一個(gè)類(lèi)型 為 T 的類(lèi)型，否則沒(méi)人知道 T 是什么，編譯期也不知道
     */
    private staticvoid testIter(Listlist) {
        for (T t : list) {
            System.out.println("t = " + t);
        }
    }
}

可以看到里面的 是不是每個(gè)方法都需要去申明一次，那要是 100 個(gè)方法呢？那是不是要申明 100 次的，這樣時(shí)候泛型類(lèi)也就應(yīng)用而生了。那泛型類(lèi)的形式是什么樣子的呢？請(qǐng)看代碼

public class GenericClazz{
    //這就是一個(gè)最基本的泛型類(lèi)的樣子
}

下面我們將剛剛的代碼優(yōu)化如下，但是這里不得不說(shuō)一個(gè)很基礎(chǔ)，但是卻很少有人注意到的問(wèn)題，請(qǐng)看下面的截圖中的文字描述部分。

# 為什么實(shí)例方法可以，而靜態(tài)方法卻報(bào)錯(cuò)？
1. 首先告訴你結(jié)論：靜態(tài)方法不能使用類(lèi)定義的泛型，而是應(yīng)該單獨(dú)定義泛型
2. 到這里估計(jì)很多小伙伴就瞬間明白了，因?yàn)殪o態(tài)方法是通過(guò)類(lèi)直接調(diào)用的，而普通方法必須通過(guò)實(shí)例來(lái)調(diào)用，類(lèi)在調(diào)用靜態(tài)方法的時(shí)候，后面的泛型類(lèi)還沒(méi)有被創(chuàng)建，所以肯定不能這么去調(diào)用的

所以說(shuō)這個(gè)泛型類(lèi)中的靜態(tài)方法直接這么寫(xiě)就可以啦

    /**
     * 遍歷集合
     *
     * @param list 集合
     */
    private staticvoid testIter(Listlist) {
        for (K t : list) {
            System.out.println("t = " + t);
        }
    }

• 多個(gè)泛型類(lèi)型同時(shí)使用

我們知道 Map 是鍵值對(duì)形式存在，所以如果對(duì) Map 的 Key 和 Value 都使用泛型類(lèi)型該怎么辦？一樣的使用，一個(gè)靜態(tài)方法就可以搞定了，請(qǐng)看下面的代碼

public class GenericMap {

    private static  void mapIter(Map map) {
        for (Map.Entry kvEntry : map.entrySet()) {
            K key = kvEntry.getKey();
            V value = kvEntry.getValue();
            System.out.println(key + ":" + value);
        }
    }

    public static void main(String[] args) {
        Map mapStr = new HashMap<>();
        mapStr.put("a", "aa");
        mapStr.put("b", "bb");
        mapStr.put("c", "cc");
        mapIter(mapStr);
        System.out.println("======");
        Map mapInteger = new HashMap<>();
        mapInteger.put(1, "11");
        mapInteger.put(2, "22");
        mapInteger.put(3, "33");
        mapIter(mapInteger);
    }
}

到此，泛型的常規(guī)的方法和泛型類(lèi)已經(jīng)介紹為了。

5. 通配符

通配符 ? 即占位符的意思，也就是在使用期間是無(wú)法確定其類(lèi)型的，只要在將來(lái)實(shí)際使用的時(shí)再指明類(lèi)型，它有三種形式

• 無(wú)限定的通配符。是讓泛型能夠接受未知類(lèi)型的數(shù)據(jù)

• < ? extends E>有上限的通配符。能接受指定類(lèi)及其子類(lèi)類(lèi)型的數(shù)據(jù)，E就是該泛型的上邊界

• 有下限的通配符。能接受指定類(lèi)及其父類(lèi)類(lèi)型的數(shù)據(jù),E就是該泛型的下邊界

5.1 通配符之

上面剛剛說(shuō)到了使用一個(gè)類(lèi)型來(lái)表示反省類(lèi)型是必須要申明的，也即 ，那是不是不申明就不能使用泛型呢？當(dāng)然不是，這小節(jié)介紹的 就是為了解決這個(gè)問(wèn)題的。

表示，但是話(huà)又說(shuō)話(huà)來(lái)了，那既然可以不去指明具體類(lèi)型，那 ? 就不能表示一個(gè)具體的類(lèi)型也就是說(shuō)如果按照原來(lái)的方式這么去寫(xiě)，請(qǐng)看代碼中的注釋

而又因?yàn)槿魏晤?lèi)型都是 Object 的子類(lèi)，所以，這里可以使用 Object 來(lái)接收，對(duì)于 ? 的具體使用會(huì)在下面兩小節(jié)介紹

另外，大家要搞明白泛型和通配符不是一回事

5.2 通配符之

表示有上限的通配符，能接受其類(lèi)型和其子類(lèi)的類(lèi)型 E 指上邊界，還是寫(xiě)個(gè)例子來(lái)說(shuō)明

public class GenericExtend {
    public static void main(String[] args) {
        ListlistF = new ArrayList<>();
        ListlistS = new ArrayList<>();
        ListlistD = new ArrayList<>();
        testExtend(listF);
        testExtend(listS);
        testExtend(listD);
    }

    private staticvoid testExtend(List list) {}
}

class Father {}

class Daughter extends Father{}

class Son extends Father {    
}

這個(gè)時(shí)候一切都還是很和平的，因?yàn)榇蠹叶甲袷刂A(yù)定，反正 List 中的泛型要么是 Father 類(lèi)，要么是 Father 的子類(lèi)。但是這個(gè)時(shí)候如果這樣子來(lái)寫(xiě)（具體原因已經(jīng)在截圖中寫(xiě)明了）

5.3 通配符之 <？super E>

<？super E> 表示有下限的通配符。也就說(shuō)能接受指定類(lèi)型及其父類(lèi)類(lèi)型，E 即泛型類(lèi)型的下邊界，直接上來(lái)代碼然后來(lái)解釋

public class GenericSuper {

    public static void main(String[] args) {
        ListlistS = new Stack<>();
        ListlistF = new Stack<>();
        ListlistG = new Stack<>();
        testSuper(listS);
        testSuper(listF);
        testSuper(listG);
        
    }
    private static void testSuper(List list){}
}
class Son extends Father{}
class Father extends GrandFather{}
class GrandFather{}

因?yàn)?List list 接受的類(lèi)型只能是 Son 或者是 Son 的父類(lèi)，而 Father 和 GrandFather 又都是 Son 的父類(lèi)，所以以上程序是沒(méi)有任何問(wèn)題的，但是如果再來(lái)一個(gè)類(lèi)是 Son 的子類(lèi)（如果不是和 Son 有關(guān)聯(lián)的類(lèi)那更不行了），那結(jié)果會(huì)怎么樣？看下圖，相關(guān)重點(diǎn)已經(jīng)在圖中詳細(xì)說(shuō)明

好了，其實(shí)泛型說(shuō)到這里基本就差不多了，我們平時(shí)開(kāi)發(fā)能遇到的問(wèn)題和不常遇見(jiàn)的問(wèn)題本文都基本講解到了。最后我們?cè)賮?lái)一起看看泛型的另一個(gè)特性：泛型擦除。

6. 泛型擦除

先來(lái)看下泛型擦除的定義

# 泛型擦除
	因?yàn)榉盒偷男畔⒅淮嬖谟?java 的編譯階段，編譯期編譯完帶有 java 泛型的程序后，其生成的 class 文件中與泛型相關(guān)的信息會(huì)被擦除掉，以此來(lái)保證程序運(yùn)行的效率并不會(huì)受影響，也就說(shuō)泛型類(lèi)型在 jvm 中和普通類(lèi)是一樣的。

別急，知道你看完概念肯定還是不明白什么叫泛型擦除，舉個(gè)例子

public class GenericWipe {
    public static void main(String[] args) {
        ListlistStr = new ArrayList<>();
        ListlistInt = new ArrayList<>();
        ListlistDou = new ArrayList<>();

        System.out.println(listStr.getClass());
        System.out.println(listInt.getClass());
        System.out.println(listDou.getClass());

    }
}

這也就是說(shuō) java 泛型在生成字節(jié)碼以后是根本不存在泛型類(lèi)型的，甚至是在編譯期就會(huì)被抹去，說(shuō)來(lái)說(shuō)去好像并沒(méi)有將泛型擦除說(shuō)的很透徹，下面我們就以例子的方式來(lái)一步一步證明

• 通過(guò)反射驗(yàn)證編譯期泛型類(lèi)型被擦除

class Demo1 {
    public static void main(String[] args) throws Exception {
        Listlist = new ArrayList<>();
        //到這里是沒(méi)有任何問(wèn)題的，正常的一個(gè) 集合類(lèi)的添加元素
        list.add(1024);
        list.forEach(System.out::println);
        System.out.println("-------通過(guò)反射證明泛型類(lèi)型編譯期間被擦除-------");
        //反射看不明白的小伙伴不要急，如果想看發(fā)射的文章，請(qǐng)留言反射，我下期保證完成
        list.getClass().getMethod("add", Object.class).invoke(list, "9527");
        for (int i = 0; i < list.size(); i++) { System.out.println("value = " + list.get(i)); } } } 

打印結(jié)果如下：

但是直接同一個(gè)反射似乎并不能讓小伙伴們買(mǎi)賬，我們?yōu)榱梭w驗(yàn)差異，繼續(xù)寫(xiě)一個(gè)例子

class Demo1 {
    public static void main(String[] args) throws Exception {
        //List實(shí)際上就是一個(gè)泛型，所以我們就不去自己另外寫(xiě)泛型類(lèi)來(lái)測(cè)試了
        Listlist = new ArrayList<>();
        //到這里是沒(méi)有任何問(wèn)題的，正常的一個(gè) 集合類(lèi)的添加元素
        list.add(1024);
        list.forEach(System.out::println);
        System.out.println("-------通過(guò)反射證明泛型類(lèi)型編譯期間被擦除-------");
        list.getClass().getMethod("add", Object.class).invoke(list, "9527");
        for (int i = 0; i < list.size(); i++) { System.out.println("value = " + list.get(i)); } //普通的類(lèi) FanShe fanShe = new FanShe(); //先通過(guò)正常的方式為屬性設(shè)置值 fanShe.setStr(1111); System.out.println(fanShe.getStr()); //然后通過(guò)同樣的方式為屬性設(shè)置值 不要忘記上面的List 是 List是泛型哦！不要連最基本的知識(shí)都忘記了 fanShe.getClass().getMethod("setStr", Object.class).invoke(list, "2222"); System.out.println(fanShe.getStr()); } } //隨便寫(xiě)一個(gè)類(lèi) class FanShe{ private Integer str; public void setStr(Integer str) { this.str = str; } public Integer getStr() { return str; } }

測(cè)試結(jié)果顯而易見(jiàn)，不是泛型的類(lèi)型是不能通過(guò)反射去修改類(lèi)型賦值的。

• 由于泛型擦除帶來(lái)的自動(dòng)類(lèi)型轉(zhuǎn)換
  

因?yàn)榉盒偷念?lèi)型擦除問(wèn)題，導(dǎo)致所有的泛型類(lèi)型變量被編譯后都會(huì)被替換為原始類(lèi)型。既然都被替換為原始類(lèi)型，那么為什么我們?cè)讷@取的時(shí)候，為什么不需要強(qiáng)制類(lèi)型轉(zhuǎn)換？

下面這么些才是一個(gè)標(biāo)準(zhǔn)的帶有泛型返回值的方法。

public class TypeConvert {
    public static void main(String[] args) {

        //調(diào)用方法的時(shí)候返回值就是我們實(shí)際傳的泛型的類(lèi)型
        MyClazz1 myClazz1 = testTypeConvert(MyClazz1.class);
        MyClazz2 myClazz2 = testTypeConvert(MyClazz2.class);
    }
    private staticT testTypeConvert(ClasstClass){
        //只需要將返回值類(lèi)型轉(zhuǎn)成實(shí)際的泛型類(lèi)型 T 即可
        return (T) tClass;
    }
}

class MyClazz1{}
class MyClazz2{}

• 由泛型引發(fā)的數(shù)組問(wèn)題

名字怪嚇人的，實(shí)際上說(shuō)白了就是不能創(chuàng)建泛型數(shù)組

看下面的代碼

為什么不能創(chuàng)建泛型類(lèi)型的數(shù)組？

因?yàn)?/span>List 和 List 被編譯后在 JVM 中等同于List ，所有的類(lèi)型信息在編譯后都等同于List，也就是說(shuō)編譯器此時(shí)也是無(wú)法區(qū)分?jǐn)?shù)組中的具體類(lèi)型是 Integer類(lèi)型還是 String 。

但是，使用通配符卻是可以的，我上文還特意強(qiáng)調(diào)過(guò)一句話(huà)：泛型和通配符不是一回事。請(qǐng)看代碼

那這又是為什么？? 表示未知的類(lèi)型，他的操作不涉及任何的類(lèi)型相關(guān)的東西，所以 JVM 是不會(huì)對(duì)其進(jìn)行類(lèi)型判斷的，因此它能編譯通過(guò)，但是這種方式只能讀不能寫(xiě)，也即只能使用 get 方法，無(wú)法使用 add 方法。

為什么不能 add ？ 提供了只讀的功能，也就是它刪減了增加具體類(lèi)型元素的能力，只保留與具體類(lèi)型無(wú)關(guān)的功能。它不管裝載在這個(gè)容器內(nèi)的元素是什么類(lèi)型，它只關(guān)心元素的數(shù)量、容器是否為空，另外上面也已經(jīng)解釋過(guò)為什么不能 add 的，這里就當(dāng)做一個(gè)補(bǔ)充。

好了，關(guān)于泛型知識(shí)，今天就聊到這里，感謝大家的支持！