這篇文章主要介紹了Java泛型的案例分析，具有一定借鑒價值，需要的朋友可以參考下。希望大家閱讀完這篇文章后大有收獲。下面讓小編帶著大家一起了解一下。
對于泛型的使用我想大家都非常熟悉，但是對于類型擦除，邊界拓展等細節問題，可能不是很清楚，所以本文會重點講解一下；另外對泛型的了解其實可以看出，一個語言特性的產生邏輯，這對我們平時的開發也是非常有幫助的；
一、為什么會出現泛型
首先泛型并不是Java的語言特性，是直到 JDK1.5 才支持的特性（具體區別后面會講到）；那么在泛型出現之前是怎么做的呢？
List list = new ArrayList();
list.add("123");
String s = (String) list.get(0);如上面代碼所示，在集合里面需要我們自己記住放進去的是什么，取出來的時候再強轉； 也就將這種類型轉換的錯誤推遲到了運行時，即麻煩還不安全，所以才出現了泛型；
使用場景：泛型類，泛型接口，泛型方法；
public class Test<T> public interface Test<T> public <T> void test(T t)
二、泛型會帶來什么樣的問題
正如上面所講泛型并不是 Java 一開始就具有的特性，所以在后來想要增加泛型的時候，就必須要兼容以前的版本，Sun 他們想到的折中解決方案就是類型擦除；意思就是泛型的信息只存在于編譯期，在運行時期所有的泛型信息都被擦除了，就想沒有一樣；
List<String> list1 = new ArrayList<>(); List<Integer> list2 = new ArrayList<>(); System.out.println(list1.getClass()); System.out.println(list2.getClass() == list1.getClass());
// 打?。?br/>class java.util.ArrayList
true
可以看到 List<String> 和 List<String> 在運行時其實都是一樣的，都是class java.util.ArrayList；所以在使用泛型的時候需要牢記，在運行時期沒有泛型信息，也無法獲取任何有關參數類型的信息；所以凡是需要獲取運行時類型的操作，泛型都不支持！
1. 不能用基本類型實例化類型參數
new ArrayList<int>(); // error new ArrayList<Integer>(); // correct
因為類型擦除，會擦除到他的上界也就是 Object；而 Java 的8個基本類型的直接父類是 Number，所以基本類型不不能用基本類型實例化類型參數，而必須使用基本類型的包裝類；
t instanceof T // error t instanceof List<T> // error t instanceof List<String> // error t instanceof List // correct
但是可以使用 clazz.isInstance(); 進行補償；
T t = new T(); // error
同樣可以使用 clazz.newInstance(); 進行補償；
private static T t; // error
private T t; // correct
private static List<T> list; // error
private static List<?> list; // correct
private static List<String> list; // correct
// e.g.
class Test<T> {
private T t;
public void set(T arg) { t = arg; }
public T get() { return t; }
}因為靜態變量在類中共享，而泛型類型是不確定的，所以泛型不能靜態化；但是非靜態的時候，編譯期可以根據上下文推斷出T是什么，例如：
Test l = new Test();
System.out.println(l.get());
l.set("123");
System.out.println(l.get());
// javap -v 反編譯
12: invokevirtual #15 // Method JDK/Test14_genericity$Test.get:()Ljava/lang/Object;
15: invokevirtual #16 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
18: aload_1
19: ldc #17 // String 123
21: invokevirtual #18 // Method JDK/Test14_genericity$Test.set:(Ljava/lang/Object;)V
24: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
// ---------------------------
Test l = new Test();
System.out.println(l.get());
l.set("123");
System.out.println(l.get());
// javap -v 反編譯
12: invokevirtual #15 // Method JDK/Test14_genericity$Test.get:()Ljava/lang/Object;
15: invokevirtual #16 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
18: aload_1
19: bipush 123
21: invokestatic #17 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;根據上面的代碼，可以很清楚的看到，編譯器對非靜態類型的推導；
另外 List<?> 和 List<String> 之所以是正確的，仍然是因為編譯器可以在編譯期間就能確定類型轉換的正確性；
5. 不能拋出或捕獲泛型類的實例
catch (T t) // error class Test<T> extends Throwable // error
因為在捕捉異常時候需要運行時類信息，并且判斷異常的繼承關系，所以不能拋出或捕獲泛型類的實例；
void test(List<Integer> list) void test(List<String> list)
因為在運行時期泛型信息被擦除，重載的兩個方法簽名就完全一樣了；
對于一點我覺得是最重要的，關于數組的介紹可以參考，Array 相關 ；
List<String>[] lists = new ArrayList<String>[10]; // error List<String>[] lists1 = (List<String>[]) new ArrayList[10]; // correct
之所以不能創建泛型數組的主要原因：
數組是協變的，而泛型的不變的；
數組的Class信息是在運行時動態創建的，而運行時不能獲取泛型的類信息；
根據上面的講解可以看出所謂的擦除補償或者擦除后的修正，其大體思路都是用額外的方法告知運行時的類型信息，可以是記錄到局部變量，也可以是指定參數的確切類型（Array.newInstance(Class<?> componentType, int length)）；
三、邊界拓展
基于安全的考慮 Java 泛型是不變的（避免取出數據時的類型轉換錯誤）；
List<Object> list = new ArrayList<String>(); // error
所以在使用集合類的時候，每個集合都需要強制指定確切類型就有點不方便，比如我想指定一個集合存放 A 以及 A 的子類；在這種情況下就引入了 extends,super,? 來拓展和管理泛型的邊界；
<?>通配符主要用于泛型的使用場景（泛型一般有“聲明”和“使用”兩種場景）；
通常情況下 <?> 和原生類型大致相同，就像 List 和 List<?> 的表現大部分都是一樣的；但是要注意他們其實是有本質去別的，<?> 代表了某一特定的類型，但是編譯器不知道這種類型是什么；而原生的表示可以是任何 Object，其中并沒有類型限制；
List<?> list = new ArrayList<String>(); // correct
list.add("34"); // error
String s = list.get(0); // error
Object o = list.get(0); // correct
boolean add(E e);上面的代碼很明確的反應了這一點（<?> 代表了某一特定的類型，但是編譯器不知道這種類型是什么），
因為編譯器不知道這種類型是什么，所以在添加元素的時候，當然也就不能確認添加的這個類型是否正確；當使用<?>的時候，代碼中的 add(E e) 方法，此時的 E 會被替換為 <?>，實際上編譯器為了安全起見，會直接拒絕參數列表中涉及通配符的方法調用；就算這個方法沒有向集合中添加元素，也會被直接拒絕；
當 List<?> 取出元素的時候，同樣因為不知道這個特定的類型是什么，所以只能將取出的元素放在Object中；或者在取出后強轉；
<extends>extends，主要用于確定泛型的上界；
<T extends Test> // 泛型聲明 <T extends Test & interface1 & interface2> // 聲明泛型是可以確定多個上界 <? extends T> // 泛型使用時
界定的范圍如圖所示：
應當注意的是當extends用于參數類型限定時：
List<? extends List> list = new ArrayList<ArrayList>(); // correct list.add(new ArrayList()); // error List l = list.get(0); // correct ArrayList l = list.get(0); // error
上面的分析同無界通配符類似，只是 List l = list.get(0); 是正確的，是因為 <? extends List> 界定了放入的元素一定是 List 或者 list 的子類，所以取出的元素能放入 List 中，但是不能放入 ArrayList 中；
<super>super，主要用于確定泛型的下界；如圖所示：
List<? super HashMap> list = new ArrayList<>(); // correct LinkedHashMap m = new LinkedHashMap(); // correct HashMap m1 = m; // correct Map m2 = m; // correct list.add(m); // correct list.add(m1); // correct list.add(m2); // error Map mm = list.get(0); // error LinkedHashMap mm1 = list.get(0); // error
根據圖中的范圍對照代碼，就能很快發現Map在List<? super HashMap>的范圍之外；而編輯器為了安全泛型下界集合取出的元素只能放在 Object里面；
PECS 原則PECS原則是對上界和下界使用的歸納，即producer-extends, consumer-super；結合上面的兩幅圖，表示：
extends，只能讀，相當于生產者，向外產出；
super，只能寫，相當于消費者，只能接收消費；
同時邊界不能同時規定上界和下界，正如圖所示，他們的范圍其實是一樣的，只是開口不一樣；
對于上面講的泛型邊界拓展，有一個很特別的用法，
class Test<T extends Test<T>> {}
public <T extends Comparable<T>> T max(List<T> list) {}自限定類型可以通俗的解釋，就是用自己限定自己，即自和自身相同的類進行某操作；如上面的 max 方法，就表示可以和自身進行比較的類型；
那么如果想要表達只要是同一祖先就能相互比較呢？
public <T extends Comparable<? super>> T max(List<? extends T> list) {}<T extends Comparable<? super>>：表明只要是同一祖先就能相互比較，<? extends T>表明集合中裝的都是同一祖先的元素；（出至《Effective Java》第 28 條）
總結
對于泛型的時候首先要很清楚的知道，在運行時沒有任何泛型的信息，全部都被擦除掉了；
需要知道 Java 泛型做不到的事情；
需要知道怎么拓展邊界，讓泛型更加靈活；
感謝你能夠認真閱讀完這篇文章，希望小編分享Java泛型的案例分析內容對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，遇到問題就找億速云，詳細的解決方法等著你來學習!
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
