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