1. Why ——引入泛型機制的原因
假如我們想要實現一個String數組，并且要求它可以動態改變大小，這時我們都會想到用ArrayList來聚合String對象。然而，過了一陣，我們想要實現一個大小可以改變的Date對象數組，這時我們當然希望能夠重用之前寫過的那個針對String對象的ArrayList實現。
在Java 5之前，ArrayList的實現大致如下：
|
1
2
3
4
5
6
|
public class ArrayList { public Object get(int i) { ... } public void add(Object o) { ... } ... private Object[] elementData;} |
從以上代碼我們可以看到，用于向ArrayList中添加元素的add函數接收一個Object型的參數，從ArrayList獲取指定元素的get方法也返回一個Object類型的對象，Object對象數組elementData存放這ArrayList中的對象， 也就是說，無論你向ArrayList中放入什么類型的類型，到了它的內部，都是一個Object對象。
基于繼承的泛型實現會帶來兩個問題：第一個問題是有關get方法的，我們每次調用get方法都會返回一個Object對象，每一次都要強制類型轉換為我們需要的類型，這樣會顯得很麻煩；第二個問題是有關add方法的，假如我們往聚合了String對象的ArrayList中加入一個File對象，編譯器不會產生任何錯誤提示，而這不是我們想要的。
所以，從Java 5開始，ArrayList在使用時可以加上一個類型參數（type parameter），這個類型參數用來指明ArrayList中的元素類型。類型參數的引入解決了以上提到的兩個問題，如以下代碼所示：
|
1
2
3
4
5
|
ArrayList<String> s = new ArrayList<String>();s.add("abc");String s = s.get(0); //無需進行強制轉換s.add(123); //編譯錯誤，只能向其中添加String對象... |
在以上代碼中，編譯器“獲知”ArrayList的類型參數String后，便會替我們完成強制類型轉換以及類型檢查的工作。
2. 泛型類
所謂泛型類（generic class）就是具有一個或多個類型參數的類。例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public class Pair<T, U> { private T first; private U second; public Pair(T first, U second) { this.first = first; this.second = second; } public T getFirst() { return first; } public U getSecond() { return second; } public void setFirst(T newValue) { first = newValue; } public void setSecond(U newValue) { second = newValue; }} |
上面的代碼中我們可以看到，泛型類Pair的類型參數為T、U，放在類名后的尖括號中。這里的T即Type的首字母，代表類型的意思，常用的還有E（element）、K（key）、V（value）等。當然不用這些字母指代類型參數也完全可以。
實例化泛型類的時候，我們只需要把類型參數換成具體的類型即可，比如實例化一個Pair<T, U>類我們可以這樣：
Pair<String, Integer> pair = new Pair<String, Integer>();
3. 泛型方法
所謂泛型方法，就是帶有類型參數的方法，它既可以定義在泛型類中，也可以定義在普通類中。例如：
|
1
2
3
4
5
|
public class ArrayAlg { public static <T> T getMiddle(T[] a) { return a[a.length / 2]; }} |
以上代碼中的getMiddle方法即為一個泛型方法，定義的格式是類型變量放在修飾符的后面、返回類型的前面。我們可以看到，以上泛型方法可以針對各種類型的數組調用，在這些數組的類型已知切有限時，雖然也可以用過重載實現，不過編碼效率要低得多。調用以上泛型方法的示例代碼如下：
String[] strings = {"aa", "bb", "cc"};
String middle = ArrayAlg.getMiddle(names);
4. 類型變量的限定
在有些情況下，泛型類或者泛型方法想要對自己的類型參數進一步加一些限制。比如，我們想要限定類型參數只能為某個類的子類或者只能為實現了某個接口的類。相關的語法如下：
<T extends BoundingType>（BoundingType是一個類或者接口）。其中的BoundingType可以多于1個，用“&”連接即可。
5. 深入理解泛型的實現
實際上，從虛擬機的角度看，不存在“泛型”概念。比如上面我們定義的泛型類Pair，在虛擬機看來（即編譯為字節碼后），它長的是這樣的：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public class Pair { private Object first; private Object second; public Pair(Object first, Object second) { this.first = first; this.second = second; } public Object getFirst() { return first; } public Object getSecond() { return second; } public void setFirst(Object newValue) { first = newValue; } public void setSecond(Object newValue) { second = newValue; }} |
上面的類是通過類型擦除得到的，是Pair泛型類對應的原始類型（raw type）。類型擦除就是把所有類型參數替換為BoundingType（若未加限定就替換為Object）。
我們可以簡單地驗證下，編譯Pair.java后，鍵入“javap -c -s Pair”可得到：
上圖中帶“descriptor”的行即為相應方法的簽名，比如從第四行我們可以看到Pair構造方法的兩個形參經過類型擦除后均已變為了Object。
由于在虛擬機中泛型類Pair變為它的raw type，因而getFirst方法返回的是一個Object對象，而從編譯器的角度看，這個方法返回的是我們實例化類時指定的類型參數的對象。實際上， 是編譯器幫我們完成了強制類型轉換的工作。也就是說編譯器會把對Pair泛型類中getFirst方法的調用轉化為兩條虛擬機指令：
第一條是對raw type方法getFirst的調用，這個方法返回一個Object對象；第二條指令把返回的Object對象強制類型轉換為當初我們指定的類型參數類型。
類型擦除也會發生于泛型方法中，如以下泛型方法：
public static <T extends Comparable> T min(T[] a)
編譯后經過類型擦除會變成下面這樣：
public static Comparable min(Comparable[] a)
方法的類型擦除會帶來一些問題，考慮以下的代碼：
|
1
2
3
4
5
6
7
8
|
class DateInterval extends Pair<Date, Date> { public void setSecond(Date second) { if (second.compareTo(getFirst()) >= 0) { super.setSecond(second); } } ...} |
以上代碼經過類型擦除后，變為：
|
1
2
3
4
|
class DateInterval extends Pair { public void setSecond(Date second) { ... } ...} |
而在DateInterval類還存在一個從Pair類繼承而來的setSecond的方法（經過類型擦除后）如下：
public void setSecond(Object second)
現在我們可以看到，這個方法與DateInterval重寫的setSecond方法具有不同的方法簽名（形參不同），所以是兩個不同的方法，然而，這兩個方法不應該是不同的方法（因為是override）。考慮以下的代碼：
|
1
2
3
4
|
DateInterval interval = new DateInterval(...);Pair<Date, Date> pair = interval;Date aDate = new Date(...);pair.setSecond(aDate); |
由以上代碼可知，pair實際引用的是DateInterval對象，因此應該調用DateInterval的setSecond方法，這里的問題是類型擦除與多態發生了沖突。
我們來梳理下為什么會發生這個問題：pair在之前被聲明為類型Pair<Date, Date>，該類在虛擬機看來只有一個“setSecond(Object)”方法。因此在運行時，虛擬機發現pair實際引用的是DateInterval對象后，會去調用DateInterval的“setSecond(Object)"，然而DateInterval類中卻只有”setSecond(Date)"方法。
解決這個問題的方法是由編譯器在DateInterval中生成一個橋方法：
|
1
2
3
|
public void setSecond(Object second) { setSecond((Date) second);} |
6. 注意事項
(1)不能用基本類型實例化類型參數
也就是說，以下語句是非法的：
Pair<int, int> pair = new Pair<int, int>();
不過我們可以用相應的包裝類型來代替。
（2）不能拋出也不能捕獲泛型類實例
泛型類擴展Throwable即為不合法，因此無法拋出或捕獲泛型類實例。但在異常聲明中使用類型參數是合法的：
|
1
2
3
4
5
6
7
8
|
public static <T extends Throwable> void doWork(T t) throws T { try { ... } catch (Throwable realCause) { t.initCause(realCause); throw t; }} |
（3）參數化類型的數組不合法
在Java中，Object[]數組可以是任何數組的父類（因為任何一個數組都可以向上轉型為它在定義時指定元素類型的父類的數組）。考慮以下代碼：
|
1
2
3
|
String[] strs = new String[10];Object[] objs = strs;obj[0] = new Date(...); |
在上述代碼中，我們將數組元素賦值為滿足父類（Object）類型，但不同于原始類型（Pair）的對象，在編譯時能夠通過，而在運行時會拋出ArrayStoreException異常。
基于以上原因，假設Java允許我們通過以下語句聲明并初始化一個泛型數組：
Pair<String, String>[] pairs = new Pair<String, String>[10];
那么在虛擬機進行類型擦除后，實際上pairs成為了Pair[]數組，我們可以將它向上轉型為Object[]數組。這時我們若往其中添加Pair<Date, Date>對象，便能通過編譯時檢查和運行時檢查，而我們的本意是只想讓這個數組存儲Pair<String, String>對象，這會產生難以定位的錯誤。因此，Java不允許我們通過以上的語句形式聲明并初始化一個泛型數組。
可用如下語句聲明并初始化一個泛型數組：
Pair<String, String>[] pairs = (Pair<String, String>[]) new Pair[10];
（4）不能實例化類型變量
不能以諸如“new T(...)", "new T[...]", "T.class"的形式使用類型變量。Java禁止我們這樣做的原因很簡單，因為存在類型擦除，所以類似于"new T(...)"這樣的語句就會變為”new Object(...)", 而這通常不是我們的本意。我們可以用如下語句代替對“new T[...]"的調用：
arrays = (T[]) new Object[N];
（5）泛型類的靜態上下文中不能使用類型變量
注意，這里我們強調了泛型類。因為普通類中可以定義靜態泛型方法，如上面我們提到的ArrayAlg類中的getMiddle方法。關于為什么有這樣的規定，請考慮下面的代碼：
|
1
2
3
4
5
6
|
public class People<T> { public static T name; public static T getName() { ... }} |
我們知道，在同一時刻，內存中可能存在不只一個People<T>類實例。假設現在內存中存在著一個People<String>對象和People<Integer>對象，而類的靜態變量與靜態方法是所有類實例共享的。那么問題來了，name究竟是String類型還是Integer類型呢？基于這個原因，Java中不允許在泛型類的靜態上下文中使用類型變量。
7. 類型通配符
介紹類型通配符前，首先介紹兩點：
（1）假設Student是People的子類，Pair<Student, Student>卻不是Pair<People, People>的子類，它們之間不存在"is-a"關系。
（2）Pair<T, T>與它的原始類型Pair之間存在”is-a"關系，Pair<T, T>在任何情況下都可以轉換為Pair類型。
現在考慮這樣一個方法：
|
1
2
3
4
|
public static void printName(Pair<People, People> p) { People p1 = p.getFirst(); System.out.println(p1.getName()); //假設People類定義了getName實例方法} |
在以上的方法中，我們想要同時能夠傳入Pair<Student, Student>和Pair<People, People>類型的參數，然而二者之間并不存在"is-a"關系。在這種情況下，Java提供給我們這樣一種解決方案：使用Pair<? extends People>作為形參的類型。也就是說，Pair<Student, Student>和Pair<People, People>都可以看作是Pair<? extends People>的子類。
形如”<? extends BoundingType>"的代碼叫做通配符的子類型限定。與之對應的還有通配符的超類型限定，格式是這樣的：<? super BoundingType>。
現在我們考慮下面這段代碼：
|
1
2
3
|
Pair<Student> students = new Pair<Student>(student1, student2);Pair<? extends People> wildchards = students;wildchards.setFirst(people1); |
以上代碼的第三行會報錯，因為wildchards是一個Pair<? extends People>對象，它的setFirst方法和getFirst方法是這樣的：
|
1
2
|
void setFirst(? extends People)? extends People getFirst() |
對于setFirst方法來說，會使得編譯器不知道形參究竟是什么類型（只知道是People的子類），而我們試圖傳入一個People對象，編譯器無法判定People和形參類型是否是”is-a"的關系，所以調用setFirst方法會報錯。而調用wildchards的getFirst方法是合法的，因為我們知道它會返回一個People的子類，而People的子類“always is a People”。（總是可以把子類對象轉換為父類對象）
而對于通配符的超類型限定的情況下，調用getter方法是非法的，而調用setter方法是合法的。
除了子類型限定和超類型限定，還有一種通配符叫做無限定的通配符，它是這樣的：<?>。這個東西我們什么時候會用到呢？考慮一下這個場景，我們調用一個會返回一個getPairs方法，這個方法會返回一組Pair<T, T>對象。其中既有Pair<Student, Student>, 還有Pair<Teacher, Teacher>對象。（Student類和Teacher類不存在繼承關系）顯然，這種情況下，子類型限定和超類型限定都不能用。這時我們可以用這樣一條語句搞定它：
Pair<?>[] pairs = getPairs(...);
