使用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> T fun(T t)；這裡的 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<T> 的 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); } }}可以看到裡面的 <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 萬用字元之 <?>上面剛剛說到了使用一個型別來表示反省型別是必須要申明的，也即 <T> ，那是不是不申明就不能使用泛型呢？當然不是，這小節介紹的 <?> 就是為了解決這個問題的。
<?> 表示，但是話又說話來了，那既然可以不去指明具體型別，那 ? 就不能表示一個具體的型別也就是說如果按照原來的方式這麼去寫，請看程式碼中的註釋
而又因為任何型別都是 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><？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<? super Son> 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{}名字怪嚇人的，實際上說白了就是不能建立泛型陣列
看下面的程式碼
為什麼不能建立泛型型別的陣列？
因為List<Integer> 和 List<String> 被編譯後在 JVM 中等同於List<Object> ，所有的型別資訊在編譯後都等同於List<Object>，也就是說編譯器此時也是無法區分陣列中的具體型別是 Integer型別還是 String 。
但是，使用萬用字元卻是可以的，我上文還特意強調過一句話：泛型和萬用字元不是一回事。請看程式碼
那這又是為什麼？? 表示未知的型別，他的操作不涉及任何的型別相關的東西，所以 JVM 是不會對其進行型別判斷的，因此它能編譯透過，但是這種方式只能讀不能寫，也即只能使用 get 方法，無法使用 add 方法。
為什麼不能 add ？<?> 提供了只讀的功能，也就是它刪減了增加具體型別元素的能力，只保留與具體型別無關的功能。它不管裝載在這個容器內的元素是什麼型別，它只關心元素的數量、容器是否為空，另外上面也已經解釋過為什麼不能 add 的，這裡就當做一個補充。