這篇文章帶給大家的內容是關於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());
class java.util.ArrayList
true
List 和List 在運行時其實都是一樣的，都是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;5. 不能拋出或捕獲泛型類別的實例
catch (T t) // error class Test<T> extends Throwable // error
void test(List<Integer> list) void test(List<String> list)
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
<?>通配符主要用于泛型的使用场景（泛型一般有“声明”和“使用”两种场景）；
通常情况下 <?> 和原生类型大致相同，就像 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的范围之外；而编辑器为了安全泛型下界集合取出的元素只能放在 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) {}总结
对于泛型的时候首先要很清楚的知道，在运行时没有任何泛型的信息，全部都被擦除掉了；
需要知道 Java 泛型做不到的事情；
需要知道怎么拓展边界，让泛型更加灵活；
以上是Java泛型的相關知識詳解（附程式碼）的詳細內容。更多資訊請關注PHP中文網其他相關文章！
