前言
泛型是Java基礎知識的重點，雖然我們在初學Java的時候，都學過泛型，覺得自己掌握對於Java泛型的使用（全是錯覺），往後的日子，當我們深入去閱讀一些框架原始碼，你就發現了，自己會的只是簡單的使用，卻看不懂別人的泛型程式碼是怎麼寫的，還可以這樣，沒錯，別人寫出來的程式碼那叫藝術，而我......
探討
Java語言為什麼存在著泛型，而像一些動態語言Python,JavaScipt卻沒有泛型的概念？
原因是，像Java，C#這樣的靜態編譯型的語言，它們在傳遞引數的時候，引數的型別，必須是明確的，看一個例子，簡單編寫一個存放int型別的棧—StackInt,程式碼如下：
public class StackInt {
private int maxSize;
private int[] items;
private int top;
public StackInt(int maxSize){
this.maxSize = maxSize;
this.items = new int[maxSize];
this.top = -1;
}
public boolean isFull(){
return this.top == this.maxSize-1;
}
public boolean isNull(){
return this.top <= -1;
}
public boolean push(int value){
if(this.isFull()){
return false;
}
this.items[++this.top] = value;
return true;
}
public int pop(){
if(this.isNull()){
throw new RuntimeException("當前棧中無資料");
}
int value = this.items[top];
--top;
return value;
}
}
在這裡使用建構函式初始化一個StackInt物件時，可以傳入String字串嗎？很明顯是不行的，我們要求的是int型別，傳入字串String型別，這樣在語法檢查階段時會報錯的，像Java這樣的靜態編譯型的語言，引數的型別要求是明確的
泛型解決了什麼問題？
引數不安全：引入泛型，能夠在編譯階段找出程式碼的問題，而不是在執行階段
泛型要求在宣告時指定實際資料型別，Java 編譯器在編譯時會對泛型程式碼做強型別檢查，並在程式碼違反型別安全時發出告警。早發現，早治理，把隱患扼殺於搖籃，在編譯時發現並修復錯誤所付出的代價遠比在執行時小。
避免型別轉換：
未使用泛型：
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); //需要在取出Value的時候進行強制轉換
使用泛型：
List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0); //不需要強制轉換
重複編碼：：通過使用泛型，可以實現通用編碼，可以處理不同型別的集合，並且型別安全且易於閱讀。像上面的StackInt類，我們不能針對每個型別去編寫對應型別的棧，那樣太麻煩了，而泛型的出現就很好的解決了這點
擴充套件
在上面的StackInt類有一些不好的地方，那就是太具體了，不夠抽象，不夠抽象，那麼它的複用性也是不高的，例如，在另外的場景下，我需要的是往棧裡存String型別的字串，或者是其他型別，那麼StackInt類就做不到了，那麼有什麼方法能夠做到呢？再寫一個StackString類，不可能，那樣不得累死。那就只有引入基類Object了，我們改進一下程式碼：
public class StackObject {
private int maxSize;
private Object[] items;
private int top;
public StackObject(int maxSize){
this.maxSize = maxSize;
this.items = new Object[maxSize];
this.top = -1;
}
public boolean isFull(){
return this.top == this.maxSize-1;
}
public boolean isNull(){
return this.top <= -1;
}
public boolean push(Object value){
if(this.isFull()){
return false;
}
this.items[++this.top] = value;
return true;
}
public Object pop(){
if(this.isNull()){
throw new RuntimeException("當前棧中無資料");
}
Object value = this.items[top];
--top;
return value;
}
}
使用StackObject可以儲存任意型別的資料，那麼這樣做，又有什麼優點和缺點呢？
優點：StackObject類變得相對抽象了，我們可以往裡面儲存任何型別的資料，這樣就避免了寫一些重複程式碼
缺點：
1、用Object表示的物件是比較抽象的，它失去了型別的特點，那麼我們在做一些運算的時候，可能會頻繁的拆箱裝箱的過程
看上面的例圖，我們理解的認為存放了兩個數值，12345和54321,將兩個進行相加，這是很常見的操作，但是報錯了，編譯器給我們的提示是，+操作運算不能用於兩個Object型別，那麼只能對其進行型別轉換，這也是我們上面說到的泛型能解決的問題，我們需要這樣做，int sum = (int)val1 + (int)val2;,同時在涉及拆箱裝箱時，是有一定效能的損耗的，關於拆箱裝箱在這裡不作描述，可以參考我寫過的隨筆—— 深入理解Java之裝箱與拆箱
2、對於我們push進去的值，我們在取出的時候，容易忘記型別轉換，或者不記得它的型別，型別轉換錯誤，這在後面的一些業務可能埋下禍根，例如下面這個場景：直到執行時錯誤才暴露出來，這是不安全的，也是違反軟體開發原則的，應該儘早的在編譯階段就發現問題，解決問題
3、使用Object太過於模糊了，沒有具體型別的意義
最好不要用到Object,因為Object是一切型別的基類，也就是說他把一些型別的特點給抹除了，比如上面存的數字，對於數字來說，加法運算就是它的一個特點，但是用了Object，它就失去了這一特點，失去型別特有的行為
引入泛型
什麼是泛型？
泛型：是被引數化的類或介面，是對型別的約定
泛型類
class name<T1, T2, ..., Tn> { /* ... */ }
一般將泛型中的類名稱為原型，而將 <> 指定的引數稱為型別引數，<> 相當於型別的約定，T就是型別，相當於一個佔位符，由我們在呼叫時指定
使用泛型改進一下上面StackObject類，但是，陣列和泛型不能很好地結合。你不能例項化具有引數化型別的陣列，例如下面的程式碼是不合格的：
public StackT(int maxSize){
this.maxSize = maxSize;
this.items = new T[maxSize];
this.top = -1;
}
Java 中不允許直接建立泛型陣列，這是因為相比於C++,C#的語法，Java泛型其實是偽泛型，這點在後面會說到，但是，可以通過建立一個型別擦除的陣列，然後轉型的方式來建立泛型陣列。
private int maxSize;
private T[] items;
private int top;
public StackT(int maxSize){
this.maxSize = maxSize;
this.items = (T[]) new Object[maxSize];
this.top = -1;
}
實際上，真的需要儲存泛型，還是使用容器更合適，回到原來的程式碼上，需要知道的是，泛型型別不能是基本型別的，需要是包裝類
上面說到了Java 中不允許直接建立泛型陣列，事實上，Java中的泛型我們是很難通new的方式去例項化物件，不僅僅是例項化物件，甚至是獲取T的真實型別也是很難的，當然通過反射的機制還是可以獲取到的，Java獲取真實型別的方式有 3 種，分別是：
1、類名.class
2、物件.getClass
3、class.forName("全限定類名")
但是，在這裡，1和2的方式都是做不到的，雖然我們在外邊明確的傳入了Integer型別，new StackT<Integer>(3);但是在StackT
類，使用T.class還是獲取不到真實型別的，第 2 種方式的話，並沒有傳入物件，前面也說到是沒有辦法new方式例項化的，而通過反射機制是可以做到的，這裡不作演示，需要了解的話可以參考 —— Java如何獲得泛型類的真實型別、 Java通過反射獲取泛型的型別
但是在C#中的泛型以及C++的模板，這是很容易做到的，所以說Java的泛型是偽泛型，Java並不是做不到像C#一樣，而是為了遷就老的JDK語法所作出的妥協，至於上面為什麼做不到這樣，這就要說到泛型的型別擦除了。
再說型別擦除之前，先說一下泛型介面，和泛型方法吧
泛型介面
介面也可以宣告泛型，泛型介面語法形式：
public interface Content<T> {
T text();
}
泛型介面有兩種實現方式：
- 實現介面的子類明確宣告泛型型別
public class ContentImpl implements Content<Integer> {
private int text;
public ContentImpl(int text) {
this.text = text;
}
public static void main(String[] args) {
ContentImpl one = new ContentImpl(10);
System.out.print(one.text());
}
}
// Output:
// 10
- 實現介面的子類不明確宣告泛型型別
public class ContentImpl<T> implements Content<T> {
private T text;
public ContentImpl(T text) {
this.text = text;
}
@Override
public T text() { return text; }
public static void main(String[] args) {
ContentImpl<String> two = new ContentImpl<>("ABC");
System.out.print(two.text());
}
}
// Output:
// ABC
泛型方法
泛型方法是引入其自己的型別引數的方法。泛型方法可以是普通方法、靜態方法以及構造方法。
泛型方法語法形式如下：
public <T> T func(T obj) {}
是否擁有泛型方法，與其所在的類是否是泛型沒有關係。
泛型方法的語法包括一個型別引數列表，在尖括號內，它出現在方法的返回型別之前。對於靜態泛型方法，型別引數部分必須出現在方法的返回型別之前。型別引數能被用來宣告返回值型別，並且能作為泛型方法得到的實際型別引數的佔位符。
使用泛型方法的時候，通常不必指明型別引數，因為編譯器會為我們找出具體的型別。這稱為型別引數推斷（type argument inference）。型別推斷只對賦值操作有效，其他時候並不起作用。如果將一個泛型方法呼叫的結果作為引數，傳遞給另一個方法，這時編譯器並不會執行推斷。編譯器會認為：呼叫泛型方法後，其返回值被賦給一個 Object 型別的變數。
public class GenericsMethod {
public static <T> void printClass(T obj) {
System.out.println(obj.getClass().toString());
}
public static void main(String[] args) {
printClass("abc");
printClass(10);
}
}
// Output:
// class java.lang.String
// class java.lang.Integer
泛型方法中也可以使用可變引數列表
public class GenericVarargsMethod {
public static <T> List<T> makeList(T... args) {
List<T> result = new ArrayList<T>();
Collections.addAll(result, args);
return result;
}
public static void main(String[] args) {
List<String> ls = makeList("A");
System.out.println(ls);
ls = makeList("A", "B", "C");
System.out.println(ls);
}
}
// Output:
// [A]
// [A, B, C]
型別擦除
事實上，Java的執行大致可以分為兩個階段，編譯階段，執行階段
那麼對於Java泛型來說，當編譯階段過後，泛型 T 是已經被擦除了，所以在執行階段，它已經丟失了 T 的具體資訊，而我們去例項化一個物件的時候，比如T c = new T();,它的發生時機是在執行階段，而在執行階段，你要new T(),就需要知道 T 的具體型別，實際上這時候 T是被替換成Integer了，而JVM是不知道T的型別的，所以是沒有辦法例項化的。
那麼，型別擦除做了什麼呢？它做了以下工作：
- 把泛型中的所有型別引數替換為 Object，如果指定型別邊界，則使用型別邊界來替換。因此，生成的位元組碼僅包含普通的類，介面和方法。
- 擦除出現的型別宣告，即去掉
<>的內容。比如T get()方法宣告就變成了Object get()；List<String>就變成了List。如有必要，插入型別轉換以保持型別安全。 - 生成橋接方法以保留擴充套件泛型型別中的多型性。型別擦除確保不為引數化型別建立新類；因此，泛型不會產生執行時開銷。
讓我們來看一個示例：
import java.util.*;
public class ErasedTypeEquivalence {
public static void main(String[] args) {
Class c1 = new ArrayList<String>().getClass();
Class c2 = new ArrayList<Integer>().getClass();
System.out.println(c1 == c2);
}
}
/* Output:
true
*/
ArrayList<String> 和 ArrayList<Integer> 應該是不同的型別。不同的型別會有不同的行為。例如，如果嘗試向 ArrayList<String> 中放入一個 Integer，所得到的行為（失敗）和 向 ArrayList<Integer> 中放入一個 Integer 所得到的行為（成功）完全不同。但是結果輸出的是true,這意味著使用泛型時，任何具體的型別資訊都被擦除了，ArrayList<Object> 和 ArrayList<Integer> 在執行時，JVM 將它們視為同一型別class java.util.ArrayList
再用一個例子來對於該謎題的補充：
import java.util.*;
class Frob {}
class Fnorkle {}
class Quark<Q> {}
class Particle<POSITION, MOMENTUM> {}
public class LostInformation {
public static void main(String[] args) {
List<Frob> list = new ArrayList<>();
Map<Frob, Fnorkle> map = new HashMap<>();
Quark<Fnorkle> quark = new Quark<>();
Particle<Long, Double> p = new Particle<>();
System.out.println(Arrays.toString(list.getClass().getTypeParameters()));
System.out.println(Arrays.toString(map.getClass().getTypeParameters()));
System.out.println(Arrays.toString(quark.getClass().getTypeParameters()));
System.out.println(Arrays.toString(p.getClass().getTypeParameters()));
}
}
/* Output:
[E]
[K,V]
[Q]
[POSITION,MOMENTUM]
*/
根據 JDK 文件，Class.getTypeParameters() “返回一個 TypeVariable 物件陣列，表示泛型宣告中宣告的型別引數...” 這暗示你可以發現這些引數型別。但是正如上例中輸出所示，你只能看到用作引數佔位符的識別符號，這並非有用的資訊。
殘酷的現實是：在泛型程式碼內部，無法獲取任何有關泛型引數型別的資訊。
以上兩個例子皆出《Java 程式設計思想》第五版 —— On Java 8中的例子，本文藉助該例子，試圖講清楚Java泛型是使用型別擦除這裡機制實現的，能力不足，有錯誤的地方，還請指正。關於On Java 8一書，已在github上開源，並有熱心的夥伴將之翻譯成中文，現在給出閱讀地址，On Java 8
擦除的問題
擦除的代價是顯著的。泛型不能用於顯式地引用執行時型別的操作中，例如轉型、instanceof 操作和 new 表示式。因為所有關於引數的型別資訊都丟失了，當你在編寫泛型程式碼時，必須時刻提醒自己，你只是看起來擁有有關引數的型別資訊而已。
考慮如下的程式碼段：
class Foo<T> {
T var;
}
看上去當你建立一個 Foo 例項時：
Foo<Cat> f = new Foo<>();
class Foo 中的程式碼應該知道現在工作於 Cat 之上。泛型語法也在強烈暗示整個類中所有 T 出現的地方都被替換，就像在 C++ 中一樣。但是事實並非如此，當你在編寫這個類的程式碼時，必須提醒自己：“不，這只是一個 Object“。
繼承問題
泛型時基於型別擦除實現的，所以，泛型型別無法向上轉型。
向上轉型是指用子類例項去初始化父類，這是物件導向中多型的重要表現。
Integer 繼承了 Object；ArrayList 繼承了 List；但是 List<Interger> 卻並非繼承了 List<Object>。
這是因為，泛型類並沒有自己獨有的 Class 類物件。比如：並不存在 List<Object>.class 或是 List<Interger>.class，Java 編譯器會將二者都視為 List.class。
如何解決上面所產生的問題：
其實並不一定要通過new的方式去例項化，我們可以通過顯式的傳入源類，一個Class<T> clazz的物件來補償擦除，例如instanceof 操作，在程式中嘗試使用 instanceof 將會失敗。型別標籤可以使用動態 isInstance() ，這樣改進程式碼：
public class Improve<T> {
//錯誤方法
public boolean f(Object arg) {
// error: illegal generic type for instanceof
if (arg instanceof T) {
return true;
}
return false;
}
//改進方法
Class<T> clazz;
public Improve(Class<T> clazz) {
this.clazz = clazz;
}
public boolean f(Object arg) {
return kind.isInstance(arg);
}
}
例項化：
試圖在 new T() 是行不通的，部分原因是由於擦除，部分原因是編譯器無法驗證 T 是否具有預設（無參）建構函式。
Java 中的解決方案是傳入一個工廠物件，並使用該物件建立新例項。方便的工廠物件只是 Class 物件，因此，如果使用型別標記，則可以使用 newInstance() 建立該型別的新物件：
class Improve<T> {
Class<T> kind;
Improve(Class<T> kind) {
this.kind = kind;
}
public T get(){
try {
return kind.newInstance();
} catch (InstantiationException |
IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
class Employee {
@Override
public String toString() {
return "Employee";
}
}
public class InstantiateGenericType {
public static void main(String[] args) {
Improve<Employee> fe = new Improve<>(Employee.class);
System.out.println(fe.get());
}
}
/* Output:
Employee
*/
通過這樣改進程式碼，可以實現建立物件的例項，但是要注意的是，newInstance();方法呼叫無參建構函式的，如果傳入的型別，沒有無參構造的話，是會丟擲InstantiationException異常的。
泛型陣列：
泛型陣列這部分，我們在上面說到可以通過建立一個型別擦除的陣列，然後轉型的方式來建立泛型陣列，這次我們可以通過顯式的傳入源類的方式來編寫StackT類，解決建立泛型陣列的問題，程式碼如下:
public class StackT<T> {
private int maxSize;
private T[] items;
private int top;
public StackT(int maxSize, Class<T> clazz){
this.maxSize = maxSize;
this.items = this.createArray(clazz);
this.top = -1;
}
public boolean isFull(){
return this.top == this.maxSize-1;
}
public boolean isNull(){
return this.top <= -1;
}
public boolean push(T value){
if(this.isFull()){
return false;
}
this.items[++this.top] = value;
return true;
}
public T pop(){
if(this.isNull()){
throw new RuntimeException("當前棧中無資料");
}
T value = this.items[top];
--top;
return value;
}
private T[] createArray(Class<T> clazz){
T[] array =(T[])Array.newInstance(clazz, this.maxSize);
return array;
}
}
邊界
有時您可能希望限制可在引數化型別中用作型別引數的型別。型別邊界可以對泛型的型別引數設定限制條件。例如，對數字進行操作的方法可能只想接受 Number 或其子類的例項。
要宣告有界型別引數，請列出型別引數的名稱，然後是 extends 關鍵字，後跟其限制類或介面。
型別邊界的語法形式如下：
<T extends XXX>
示例：
public class GenericsExtendsDemo01 {
static <T extends Comparable<T>> T max(T x, T y, T z) {
T max = x; // 假設x是初始最大值
if (y.compareTo(max) > 0) {
max = y; //y 更大
}
if (z.compareTo(max) > 0) {
max = z; // 現在 z 更大
}
return max; // 返回最大物件
}
public static void main(String[] args) {
System.out.println(max(3, 4, 5));
System.out.println(max(6.6, 8.8, 7.7));
System.out.println(max("pear", "apple", "orange"));
}
}
// Output:
// 5
// 8.8
// pear
示例說明：
上面的示例宣告瞭一個泛型方法，型別引數
T extends Comparable<T>表明傳入方法中的型別必須實現了 Comparable 介面。
型別邊界可以設定多個，語法形式如下：
<T extends B1 & B2 & B3>
注意：extends 關鍵字後面的第一個型別引數可以是類或介面，其他型別引數只能是介面。
萬用字元
萬用字元是Java泛型中的一個非常重要的知識點。很多時候，我們其實不是很理解萬用字元？和泛型型別T區別，容易混淆在一起，其實還是很好理解的，？和 T 都表示不確定的型別，區別在於我們可以對 T 進行操作，但是對 ？不行，比如如下這種 :
// 可以
T t = operate();
// 不可以
? car = operate();
但是這個並不是我們混淆的原因，雖然？和 T 都表示不確定的型別，T 通常用於泛型類和泛型方法的定義，？通常用於泛型方法的呼叫程式碼和形參，不能用於定義類和泛型方法。用程式碼解釋一下，回到文章最初說的棧類StackT,我們以這個為基礎來解釋，上面的觀點：
public class Why {
public static void main(String[] args) {
StackT<Integer> stackT = new StackT<>(3, Integer.class);
stackT.push(8);
StackT<String> stackT1 = new StackT<>(3, String.class);
stackT1.push("7");
test(stackT1);
}
public static void test(StackT stackT){
System.out.println(stackT.pop());
}
}
// Output: 8
以我們編寫的StackT類，進行測試，編寫一個test方法，傳入引數型別StackT,上面的程式正常輸出字串"7" ，這沒有什麼問題，問題在這裡失去了泛型的限定，傳進去的實參StackT1,是被我們限定為StackT<String> ,但是我們通過編譯器可以看到stackT.pop()出來的物件，並沒有String型別的特有方法，也就是說，它其實是Object類
那麼我們就需要修改test方法的形參，改為：
public static void test(StackT<String> stackT){
System.out.println(stackT.pop());
}
這樣子就回到了我們問題的本質來了，將形參修改為StackT<String>,這起到了泛型的限定作用，但是會出現這樣的問題，如果我們需要向該方法傳入StackT<Integer>型別的物件 stackT是，因為方法形參限定了StackT<String>,，這時候就報錯了
這個時候就是萬用字元?起作用了，將方法形參改為StackT<?>就可以了，這也就確定了我們剛剛的結論，？萬用字元通常是用於泛型傳參，而不是泛型類的定義。
public static void test(StackT<?> stackT){
System.out.println(stackT.pop());
}
但是這種用法我們通常也不會去用，因為它還是失去了型別的特點，即當無界泛型萬用字元作為形參時，作為呼叫方，並不限定傳遞的實際引數型別。但是，在方法內部，泛型類的引數和返回值為泛型的方法，不能使用！
這裡，StackT.push就不能用了，因為我並不知道?傳的是Integer還是String ,還是其他型別，所以是會報錯的。
但是我們有時候是有這樣的需求的，我們在接收泛型棧StackT作為形參的時候,我想表達一種約束的關係，但是又不像StackT<String>一樣，約束的比較死板，而Java是物件導向的語言，那麼就會有繼承的機制，我想要的約束關係是我能接收的泛型棧的型別都是Number類的派生類，即不會像?無界萬用字元一樣失去類的特徵，又不會像StackT<String>約束的很死，這就引出了上界萬用字元的概念。
上界萬用字元
可以使用上界萬用字元來縮小型別引數的型別範圍。
它的語法形式為：<? extends Number>
public class Why {
public static void main(String[] args) {
StackT<Integer> stackT = new StackT<>(3, Integer.class);
stackT.push(8);
StackT<String> stackT1 = new StackT<>(3, String.class);
stackT1.push("7");
StackT<Double> stackT2 = new StackT<>(3, Double.class);
//通過
test(stackT);
test(stackT2);
//error
test(stackT1);
}
public static void test(StackT<? extends Number> stackT){
System.out.println(stackT.pop());
}
}
這樣就實現了一類型別的限定，但是需求變更了，我現在希望的約束關係是我能接收的泛型棧的型別都是Number類的父類，或者父類的父類，那麼有上界，自然就有下界
下界萬用字元
下界萬用字元將未知型別限制為該型別的特定型別或超類型別。
注意：上界萬用字元和下界萬用字元不能同時使用。
它的語法形式為：<? super Number>
public class Why {
public static void main(String[] args) {
StackT<Number> stackT1 = new StackT<>(3, Number.class);
stackT1.push(8);
StackT<Double> stackT2 = new StackT<>(3, Double.class);
StackT<Object> stackT3 = new StackT<>(3, Object.class);
//通過
test(stackT1);
test(stackT3);
//error
test(stackT2);
}
public static void test(StackT<? super Number> stackT){
System.out.println(stackT.pop());
}
}
這樣子的話，就確保了我們的test方法只接收Number型別以上的方法。泛型的各種高階語法可能在寫業務程式碼的時候可以規避，但是如果你要去寫一些框架的時候，由於你不知道框架的使用者的使用場景，那麼掌握泛型的高階語法就很有用了。
萬用字元和向上轉型
前面，我們提到：泛型不能向上轉型。但是，我們可以通過使用萬用字元來向上轉型。
public class GenericsWildcardDemo {
public static void main(String[] args) {
List<Integer> intList = new ArrayList<>();
List<Number> numList = intList; // Error
List<? extends Integer> intList2 = new ArrayList<>();
List<? extends Number> numList2 = intList2; // OK
}
}
萬用字元邊界問題，關於一些更加深入的解惑可以參考整理的轉載的文章——Java泛型解惑之上下萬用字元
泛型約束
Pair<int, char> p = new Pair<>(8, 'a'); // 編譯錯誤
public static <E> void append(List<E> list) {
E elem = new E(); // 編譯錯誤
list.add(elem);
}
public class MobileDevice<T> {
private static T os; // error
// ...
}
public static <E> void rtti(List<E> list) {
if (list instanceof ArrayList<Integer>) { // 編譯錯誤
// ...
}
}
List<Integer> li = new ArrayList<>();
List<Number> ln = (List<Number>) li; // 編譯錯誤
List<Integer>[] arrayOfLists = new List<Integer>[2]; // 編譯錯誤
// Extends Throwable indirectly
class MathException<T> extends Exception { /* ... */ } // 編譯錯誤
// Extends Throwable directly
class QueueFullException<T> extends Throwable { /* ... */ // 編譯錯誤
public static <T extends Exception, J> void execute(List<J> jobs) {
try {
for (J job : jobs)
// ...
} catch (T e) { // compile-time error
// ...
}
}
public class Example {
public void print(Set<String> strSet) { }
public void print(Set<Integer> intSet) { } // 編譯錯誤
}
實踐總結
泛型命名
泛型一些約定俗成的命名：
- E - Element
- K - Key
- N - Number
- T - Type
- V - Value
- S,U,V etc. - 2nd, 3rd, 4th types
使用泛型的建議
- 消除型別檢查告警
- List 優先於陣列
- 優先考慮使用泛型來提高程式碼通用性
- 優先考慮泛型方法來限定泛型的範圍
- 利用有限制萬用字元來提升 API 的靈活性
- 優先考慮型別安全的異構容器
參考資料：
Java泛型解惑之 extends T>和 super T>上下界限
7月的直播課——Java 高階語法—泛型