Java的“泛型”特性，你以為自己會了？

作者：坨坨 2021-02-08 11:20:27

使用Java的小伙伴，對于Java的一些高級特性一定再熟悉不過了，例如集合、反射、泛型、注解等等，這些可以說我們在平時開發中是經常使用到的，尤其是集合，基本是只要寫代碼沒有用不到的，今天我們先來談談泛型。

1. 定義

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

# 泛型(generics)

他是 JDK5 中引入的一個新特性，泛型提供了編譯時類型安全監測機制，該機制允許我們在編譯時檢測到非法的類型數據結構。泛型的本質就是參數化類型，也就是所操作的數據類型被指定為一個參數# 常見的泛型的類型表示上面的 T 僅僅類似一個形參的作用，名字實際上是可以任意起的，但是我們寫代碼總該是要講究可讀性的。常見的參數通常有 :E - Element (在集合中使用，因為集合中存放的是元素)T - Type(表示Java 類，包括基本的類和我們自定義的類)K - Key(表示鍵，比如Map中的key)V - Value(表示值)? - (表示不確定的java類型)但是泛型的參數只能是類類型，不能是基本的數據類型，他的類型一定是自Object的

注意：泛型不接受基本數據類型，換句話說，只有引用類型才能作為泛型方法的實際參數

2. 為什么要使用泛型?

說到為什么要使用，那肯定是找一大堆能說服自己的優點啊。

# 泛型的引入，是java語言的來講是一個較大的功能增強。同時對于編譯器也帶來了一定的增強，為了支持泛型，java的類庫都做相應的修改以支持泛型的特性。(科普：實際上java泛型并不是 jdk5(2004發布了jdk5) 才提出來的，早在1999年的時候，泛型機制就是java最早的規范之一)

另外，泛型還具有以下的優點：

# 1.提交了java的類型安全

泛型在很大程度上來提高了java的程序安全。例如在沒有泛型的情況下，很容易將字符串 123 轉成 Integer 類型的 123 亦或者 Integer 轉成 String，而這樣的錯誤是在編譯期無法檢測。而使用泛型，則能很好的避免這樣的情況發生。

# 2.不需要煩人的強制類型轉換

泛型之所以能夠消除強制類型轉換，那是因為程序員在開發的時候就已經明確了自己使用的具體類型，這不但提高了代碼的可讀性，同樣增加了代碼的健壯性。

# 提高了代碼的重用性

泛型的程序設計，意味著編寫的代碼可以被很多不同類型的對象所重用

在泛型規范正式發布之前，泛型的程序設計是通過繼承來實現的，但是這樣子有兩個嚴重的問題：

① 取值的時候需要強制類型轉換，否則拿到的都是 Object

② 編譯期不會有錯誤檢查

我們來看下這兩個錯誤的產生

2.1 編譯期不會有錯誤檢查

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

程序不但不會報錯，還能正常輸出

2.2 強制類型轉換

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

因為你并不知道實際集合中的元素到底是哪些類型的，所以在使用的時候也是不確定的，如果在強轉的時候，那必然會帶來意想不到的錯誤，這樣潛在的問題就好像是定時炸彈，肯定是不允許發生的。所以這就更體現了泛型的重要性。

3. 泛型方法

在 java 中，泛型方法可以使用在成員方法、構造方法和靜態方法中。語法如下：

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

下面來通過具體的例子來解釋說明，以下代碼將數組中的指定的兩個下標位置的元素進行交換(不要去關注實際的需求是什么)，第一種 Integer 類型的數組

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)); 
  } 
 
   /** 
    * 將數組中的指定兩個下標位置的元素交換 
    * 
    * @param arr         數組 
    * @param firstIndex 第一個下標 
    * @param secondIndex 第二個下標 
    */ 
   private static void change(Integer[] arr, int firstIndex, int secondIndex) { 
       int tmp = arr[firstIndex]; 
       arr[firstIndex] = arr[secondIndex]; 
       arr[secondIndex] = tmp; 
  } 
}

第二種是 String 類型的數組

編譯直接都不會通過，那是必然的，因為方法定義的參數就是 Integer[] 結果你傳一個String[]，玩呢。。。所以這個時候只能是再定義一個參數類型是 String[]的。

那要是再來一個 Double 呢?Boolean 呢?是不是這就產生問題了，雖然說這種問題不是致命的，多寫一些重復的代碼就能解決，但這勢必導致代碼的冗余和維護成本的增加。所以這個時候泛型的作用就體現了，我們將其改成泛型的方式。

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

接下來調用就簡單了

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

問題迎刃而解，至于普通的泛型方法和靜態的泛型方法是一樣的使用，只不過是一個數據類一個屬于類的實例的，在使用上區別不大(但是需要注意的是如果在泛型類中靜態泛型方法是不能使用類泛型中的泛型類型的，這個在下文的泛型類中會詳細介紹的)。

最后在來看下構造方法

public class Father { 
    public <T> Father(T t) { 
    } 
}

然后假設他有一個子類是這樣子的

class Son extends Father { 
 
    public <T> Son(T t) { 
        super(t); 
    } 
}

這里強調一下，因為在 Father 類中是沒有無參構造器的，取而代之的是一個有參的構造器，只不過這個構造方法是一個泛型的方法，那這樣子的子類必然需要顯示的指明構造器了。

通過泛型方法獲取集合中的元素測試

既然說泛型是在申明的時候類型不是重點，只要事情用的時候確定就可以下，那你看下面這個怎么解釋?

此時想往集合中添加元素，卻提示這樣的錯誤，連編譯都過不了。這是為什么?

因為此時集合 List 的 add 方法，添加的類型為 T，但是很顯然 T 是一個泛型，真正的類型是在使用時候才能確定的，但是在 add 的并不能確定 T 的類型，所以根本就無法使用 add 方法，除非 list.add(null)，但是這卻沒有任何意義。

4. 泛型類

先來看一段這樣的代碼，里面的使用到了多個泛型的方法，無需關注方法到底做了什么

public class GenericClassTest{ 
    public static void main(String[] args) { 
        //首先定義一個Integer類型的數組 
        Integer[] arrInt = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 
        //將第 1 個和第 9 個位置的元素進行交換 
 
       new GenericClassTest().changeT(arrInt, 0, 8); 
        System.out.println("arrInt = " + Arrays.asList(arrInt)); 
 
        List<String> list = Arrays.asList("a", "b"); 
        testIter(list); 
    } 
 
    /** 
     * @param t           參數類型 T 
     * @param firstIndex  第一個下標 
     * @param secondIndex 第二個下標 
     * @param <T>         表示定義了一個類型 為 T 的類型，否則沒人知道 T 是什么，編譯期也不知道 
     */ 
    private <T> void changeT(T[] t, int firstIndex, int secondIndex) { 
        T tmp = t[firstIndex]; 
        t[firstIndex] = t[secondIndex]; 
        t[secondIndex] = tmp; 
    } 
 
    /** 
     * 遍歷集合 
     * 
     * @param list 集合 
     * @param <T>  表示定義了一個類型 為 T 的類型，否則沒人知道 T 是什么，編譯期也不知道 
     */ 
    private static <T> void testIter(List<T> list) { 
        for (T t : list) { 
            System.out.println("t = " + t); 
        } 
    } 
}

可以看到里面的是不是每個方法都需要去申明一次，那要是 100 個方法呢?那是不是要申明 100 次的，這樣時候泛型類也就應用而生了。那泛型類的形式是什么樣子的呢?請看代碼

public class GenericClazz<T>{ 
    //這就是一個最基本的泛型類的樣子 
}

下面我們將剛剛的代碼優化如下，但是這里不得不說一個很基礎，但是卻很少有人注意到的問題，請看下面的截圖中的文字描述部分。

# 為什么實例方法可以，而靜態方法卻報錯?1. 首先告訴你結論：靜態方法不能使用類定義的泛型，而是應該單獨定義泛型2. 到這里估計很多小伙伴就瞬間明白了，因為靜態方法是通過類直接調用的，而普通方法必須通過實例來調用，類在調用靜態方法的時候，后面的泛型類還沒有被創建，所以肯定不能這么去調用的

所以說這個泛型類中的靜態方法直接這么寫就可以啦

/** 
     * 遍歷集合 
     * 
     * @param list 集合 
     */ 
    private static <K> void testIter(List<K> list) { 
        for (K t : list) { 
            System.out.println("t = " + t); 
        } 
    }

多個泛型類型同時使用

我們知道 Map 是鍵值對形式存在，所以如果對 Map 的 Key 和 Value 都使用泛型類型該怎么辦?一樣的使用，一個靜態方法就可以搞定了，請看下面的代碼

public class GenericMap { 
 
    private static <K, V> void mapIter(Map<K, V> map) { 
        for (Map.Entry<K, V> kvEntry : map.entrySet()) { 
            K key = kvEntry.getKey(); 
            V value = kvEntry.getValue(); 
            System.out.println(key + ":" + value); 
        } 
    } 
 
    public static void main(String[] args) { 
        Map<String, String> mapStr = new HashMap<>(); 
        mapStr.put("a", "aa"); 
        mapStr.put("b", "bb"); 
        mapStr.put("c", "cc"); 
        mapIter(mapStr); 
        System.out.println("======"); 
        Map<Integer, String> mapInteger = new HashMap<>(); 
        mapInteger.put(1, "11"); 
        mapInteger.put(2, "22"); 
        mapInteger.put(3, "33"); 
        mapIter(mapInteger); 
    } 
}

到此，泛型的常規的方法和泛型類已經介紹為了。

5. 通配符

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

<?> 無限定的通配符。是讓泛型能夠接受未知類型的數據
< ? extends E>有上限的通配符。能接受指定類及其子類類型的數據，E就是該泛型的上邊界
<? super E>有下限的通配符。能接受指定類及其父類類型的數據,E就是該泛型的下邊界

5.1 通配符之

上面剛剛說到了使用一個類型來表示反省類型是必須要申明的，也即，那是不是不申明就不能使用泛型呢?當然不是，這小節介紹的就是為了解決這個問題的。

表示，但是話又說話來了，那既然可以不去指明具體類型，那 ? 就不能表示一個具體的類型也就是說如果按照原來的方式這么去寫，請看代碼中的注釋

而又因為任何類型都是 Object 的子類，所以，這里可以使用 Object 來接收，對于 ?的具體使用會在下面兩小節介紹

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

5.2 通配符之 <? extend E>

<? extend E> 表示有上限的通配符，能接受其類型和其子類的類型 E 指上邊界，還是寫個例子來說明

public class GenericExtend { 
    public static void main(String[] args) { 
        List<Father> listF = new ArrayList<>(); 
        List<Son> listS = new ArrayList<>(); 
        List<Daughter> listD = new ArrayList<>(); 
        testExtend(listF); 
        testExtend(listS); 
        testExtend(listD); 
    } 
 
    private static <T> void testExtend(List<? extends Father> list) {} 
} 
 
class Father {} 
 
class Daughter extends Father{} 
 
class Son extends Father {     
}

這個時候一切都還是很和平的，因為大家都遵守著預定，反正 List 中的泛型要么是 Father 類，要么是 Father 的子類。但是這個時候如果這樣子來寫(具體原因已經在截圖中寫明了)

5.3 通配符之 <？super E>

表示有下限的通配符。也就說能接受指定類型及其父類類型，E 即泛型類型的下邊界，直接上來代碼然后來解釋

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

因為 List list 接受的類型只能是 Son 或者是 Son 的父類，而 Father 和 GrandFather 又都是 Son 的父類，所以以上程序是沒有任何問題的，但是如果再來一個類是 Son 的子類(如果不是和 Son 有關聯的類那更不行了)，那結果會怎么樣?看下圖，相關重點已經在圖中詳細說明

好了，其實泛型說到這里基本就差不多了，我們平時開發能遇到的問題和不常遇見的問題本文都基本講解到了。最后我們再來一起看看泛型的另一個特性：泛型擦除。

6. 泛型擦除

先來看下泛型擦除的定義

# 泛型擦除因為泛型的信息只存在于 java 的編譯階段，編譯期編譯完帶有 java 泛型的程序后，其生成的 class 文件中與泛型相關的信息會被擦除掉，以此來保證程序運行的效率并不會受影響，也就說泛型類型在 jvm 中和普通類是一樣的。

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

public class GenericWipe { 
    public static void main(String[] args) { 
        List<String> listStr = new ArrayList<>(); 
        List<Integer> listInt = new ArrayList<>(); 
        List<Double> listDou = new ArrayList<>(); 
 
        System.out.println(listStr.getClass()); 
        System.out.println(listInt.getClass()); 
        System.out.println(listDou.getClass()); 
 
    } 
}

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

通過反射驗證編譯期泛型類型被擦除

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

打印結果如下：

但是直接同一個反射似乎并不能讓小伙伴們買賬，我們為了體驗差異，繼續寫一個例子

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

測試結果顯而易見，不是泛型的類型是不能通過反射去修改類型賦值的。

由于泛型擦除帶來的自動類型轉換

因為泛型的類型擦除問題，導致所有的泛型類型變量被編譯后都會被替換為原始類型。既然都被替換為原始類型，那么為什么我們在獲取的時候，為什么不需要強制類型轉換?

下面這么些才是一個標準的帶有泛型返回值的方法。

public class TypeConvert { 
    public static void main(String[] args) { 
 
        //調用方法的時候返回值就是我們實際傳的泛型的類型 
        MyClazz1 myClazz1 = testTypeConvert(MyClazz1.class); 
        MyClazz2 myClazz2 = testTypeConvert(MyClazz2.class); 
    } 
    private static <T> T testTypeConvert(Class<T> tClass){ 
        //只需要將返回值類型轉成實際的泛型類型 T 即可 
        return (T) tClass; 
    } 
} 
 
class MyClazz1{} 
class MyClazz2{}