1. Why ——引入泛型機制的原因

    假如我們想要實現(xiàn)一個String數(shù)組，并且要求它可以動態(tài)改變大小，這時我們都會想到用ArrayList來聚合String對象。然而，過了一陣，我們想要實現(xiàn)一個大小可以改變的Date對象數(shù)組，這時我們當然希望能夠重用之前寫過的那個針對String對象的ArrayList實現(xiàn)。

    在Java 5之前，ArrayList的實現(xiàn)大致如下：

public class ArrayList {
  public Object get(int i) { ... }
  public void add(Object o) { ... }
  ...
  private Object[] elementData;
}

    從以上代碼我們可以看到，用于向ArrayList中添加元素的add函數(shù)接收一個Object型的參數(shù)，從ArrayList獲取指定元素的get方法也返回一個Object類型的對象，Object對象數(shù)組elementData存放這ArrayList中的對象， 也就是說，無論你向ArrayList中放入什么類型的類型，到了它的內(nèi)部，都是一個Object對象。

    基于繼承的泛型實現(xiàn)會帶來兩個問題：第一個問題是有關(guān)get方法的，我們每次調(diào)用get方法都會返回一個Object對象，每一次都要強制類型轉(zhuǎn)換為我們需要的類型，這樣會顯得很麻煩；第二個問題是有關(guān)add方法的，假如我們往聚合了String對象的ArrayList中加入一個File對象，編譯器不會產(chǎn)生任何錯誤提示，而這不是我們想要的。

    所以，從Java 5開始，ArrayList在使用時可以加上一個類型參數(shù)（type parameter），這個類型參數(shù)用來指明ArrayList中的元素類型。類型參數(shù)的引入解決了以上提到的兩個問題，如以下代碼所示：

ArrayList<String> s = new ArrayList<String>();
s.add("abc");
String s = s.get(0); //無需進行強制轉(zhuǎn)換
s.add(123); //編譯錯誤，只能向其中添加String對象
...

  在以上代碼中，編譯器“獲知”ArrayList的類型參數(shù)String后，便會替我們完成強制類型轉(zhuǎn)換以及類型檢查的工作。

2. 泛型類

    所謂泛型類（generic class）就是具有一個或多個類型參數(shù)的類。例如：

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）等。當然不用這些字母指代類型參數(shù)也完全可以。

    實例化泛型類的時候，我們只需要把類型參數(shù)換成具體的類型即可，比如實例化一個Pair<T, U>類我們可以這樣：

Pair<String, Integer> pair = new Pair<String, Integer>();

3. 泛型方法

    所謂泛型方法，就是帶有類型參數(shù)的方法，它既可以定義在泛型類中，也可以定義在普通類中。例如：

public class ArrayAlg {
  public static <T> T getMiddle(T[] a) {
    return a[a.length / 2];
  }
}

    以上代碼中的getMiddle方法即為一個泛型方法，定義的格式是類型變量放在修飾符的后面、返回類型的前面。我們可以看到，以上泛型方法可以針對各種類型的數(shù)組調(diào)用，在這些數(shù)組的類型已知切有限時，雖然也可以用過重載實現(xiàn)，不過編碼效率要低得多。調(diào)用以上泛型方法的示例代碼如下：

String[] strings = {"aa", "bb", "cc"};
String middle = ArrayAlg.getMiddle(names);

4. 類型變量的限定

    在有些情況下，泛型類或者泛型方法想要對自己的類型參數(shù)進一步加一些限制。比如，我們想要限定類型參數(shù)只能為某個類的子類或者只能為實現(xiàn)了某個接口的類。相關(guān)的語法如下：

    <T extends BoundingType>（BoundingType是一個類或者接口）。其中的BoundingType可以多于1個，用“&”連接即可。

5. 深入理解泛型的實現(xiàn)

    實際上，從虛擬機的角度看，不存在“泛型”概念。比如上面我們定義的泛型類Pair，在虛擬機看來（即編譯為字節(jié)碼后），它長的是這樣的：

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）。

     我們可以簡單地驗證下，編譯Pair.java后，鍵入“javap -c -s Pair”可得到：

    上圖中帶“descriptor”的行即為相應(yīng)方法的簽名，比如從第四行我們可以看到Pair構(gòu)造方法的兩個形參經(jīng)過類型擦除后均已變?yōu)榱薕bject。

    由于在虛擬機中泛型類Pair變?yōu)樗膔aw type，因而getFirst方法返回的是一個Object對象，而從編譯器的角度看，這個方法返回的是我們實例化類時指定的類型參數(shù)的對象。實際上， 是編譯器幫我們完成了強制類型轉(zhuǎn)換的工作。也就是說編譯器會把對Pair泛型類中g(shù)etFirst方法的調(diào)用轉(zhuǎn)化為兩條虛擬機指令：

    第一條是對raw type方法getFirst的調(diào)用，這個方法返回一個Object對象；第二條指令把返回的Object對象強制類型轉(zhuǎn)換為當初我們指定的類型參數(shù)類型。

    類型擦除也會發(fā)生于泛型方法中，如以下泛型方法：

public static <T extends Comparable> T min(T[] a)
    編譯后經(jīng)過類型擦除會變成下面這樣：

public static Comparable min(Comparable[] a)
    方法的類型擦除會帶來一些問題，考慮以下的代碼：

class DateInterval extends Pair<Date, Date> {
  public void setSecond(Date second) {
    if (second.compareTo(getFirst()) >= 0) {
      super.setSecond(second);
    }
  }
  ...
}

    以上代碼經(jīng)過類型擦除后，變?yōu)椋?/p>

class DateInterval extends Pair {
  public void setSecond(Date second) { ... }
  ...
}

    而在DateInterval類還存在一個從Pair類繼承而來的setSecond的方法（經(jīng)過類型擦除后）如下：

public void setSecond(Object second)
    現(xiàn)在我們可以看到，這個方法與DateInterval重寫的setSecond方法具有不同的方法簽名（形參不同），所以是兩個不同的方法，然而，這兩個方法不應(yīng)該是不同的方法（因為是override）?？紤]以下的代碼：

DateInterval interval = new DateInterval(...);
Pair<Date, Date> pair = interval;
Date aDate = new Date(...);
pair.setSecond(aDate);

    由以上代碼可知，pair實際引用的是DateInterval對象，因此應(yīng)該調(diào)用DateInterval的setSecond方法，這里的問題是類型擦除與多態(tài)發(fā)生了沖突。

    我們來梳理下為什么會發(fā)生這個問題：pair在之前被聲明為類型Pair<Date, Date>，該類在虛擬機看來只有一個“setSecond(Object)”方法。因此在運行時，虛擬機發(fā)現(xiàn)pair實際引用的是DateInterval對象后，會去調(diào)用DateInterval的“setSecond(Object)"，然而DateInterval類中卻只有”setSecond(Date)"方法。

    解決這個問題的方法是由編譯器在DateInterval中生成一個橋方法：

public void setSecond(Object second) {
  setSecond((Date) second);
}

6. 注意事項

(1)不能用基本類型實例化類型參數(shù)

    也就是說，以下語句是非法的：

Pair<int, int> pair = new Pair<int, int>();
 不過我們可以用相應(yīng)的包裝類型來代替。

（2）不能拋出也不能捕獲泛型類實例

    泛型類擴展Throwable即為不合法，因此無法拋出或捕獲泛型類實例。但在異常聲明中使用類型參數(shù)是合法的：

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ù)組的父類（因為任何一個數(shù)組都可以向上轉(zhuǎn)型為它在定義時指定元素類型的父類的數(shù)組）?？紤]以下代碼：

String[] strs = new String[10];
Object[] objs = strs;
obj[0] = new Date(...);

  在上述代碼中，我們將數(shù)組元素賦值為滿足父類（Object）類型，但不同于原始類型（Pair）的對象，在編譯時能夠通過，而在運行時會拋出ArrayStoreException異常。

  基于以上原因，假設(shè)Java允許我們通過以下語句聲明并初始化一個泛型數(shù)組：

Pair<String, String>[] pairs = new Pair<String, String>[10];
  那么在虛擬機進行類型擦除后，實際上pairs成為了Pair[]數(shù)組，我們可以將它向上轉(zhuǎn)型為Object[]數(shù)組。這時我們?nèi)敉渲刑砑覲air<Date, Date>對象，便能通過編譯時檢查和運行時檢查，而我們的本意是只想讓這個數(shù)組存儲Pair<String, String>對象，這會產(chǎn)生難以定位的錯誤。因此，Java不允許我們通過以上的語句形式聲明并初始化一個泛型數(shù)組。

   可用如下語句聲明并初始化一個泛型數(shù)組：

Pair<String, String>[] pairs = (Pair<String, String>[]) new Pair[10];

（4）不能實例化類型變量

    不能以諸如“new T(...)", "new T[...]", "T.class"的形式使用類型變量。Java禁止我們這樣做的原因很簡單，因為存在類型擦除，所以類似于"new T(...)"這樣的語句就會變?yōu)椤眓ew Object(...)", 而這通常不是我們的本意。我們可以用如下語句代替對“new T[...]"的調(diào)用：

arrays = (T[]) new Object[N];
 

（5）泛型類的靜態(tài)上下文中不能使用類型變量

     注意，這里我們強調(diào)了泛型類。因為普通類中可以定義靜態(tài)泛型方法，如上面我們提到的ArrayAlg類中的getMiddle方法。關(guān)于為什么有這樣的規(guī)定，請考慮下面的代碼：

public class People<T> {
  public static T name;
  public static T getName() {
    ...
  }
}

    我們知道，在同一時刻，內(nèi)存中可能存在不只一個People<T>類實例。假設(shè)現(xiàn)在內(nèi)存中存在著一個People<String>對象和People<Integer>對象，而類的靜態(tài)變量與靜態(tài)方法是所有類實例共享的。那么問題來了，name究竟是String類型還是Integer類型呢？基于這個原因，Java中不允許在泛型類的靜態(tài)上下文中使用類型變量。

7. 類型通配符

    介紹類型通配符前，首先介紹兩點：

（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)在考慮這樣一個方法：

public static void printName(Pair<People, People> p) {
  People p1 = p.getFirst();
  System.out.println(p1.getName()); //假設(shè)People類定義了getName實例方法
}

    在以上的方法中，我們想要同時能夠傳入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)在我們考慮下面這段代碼：

Pair<Student> students = new Pair<Student>(student1, student2);
Pair<? extends People> wildchards = students;
wildchards.setFirst(people1); 

    以上代碼的第三行會報錯，因為wildchards是一個Pair<? extends People>對象，它的setFirst方法和getFirst方法是這樣的：

void setFirst(? extends People)
? extends People getFirst()

    對于setFirst方法來說，會使得編譯器不知道形參究竟是什么類型（只知道是People的子類），而我們試圖傳入一個People對象，編譯器無法判定People和形參類型是否是”is-a"的關(guān)系，所以調(diào)用setFirst方法會報錯。而調(diào)用wildchards的getFirst方法是合法的，因為我們知道它會返回一個People的子類，而People的子類“always is a People”。（總是可以把子類對象轉(zhuǎn)換為父類對象）

    而對于通配符的超類型限定的情況下，調(diào)用getter方法是非法的，而調(diào)用setter方法是合法的。

    除了子類型限定和超類型限定，還有一種通配符叫做無限定的通配符，它是這樣的：<?>。這個東西我們什么時候會用到呢？考慮一下這個場景，我們調(diào)用一個會返回一個getPairs方法，這個方法會返回一組Pair<T, T>對象。其中既有Pair<Student, Student>,  還有Pair<Teacher, Teacher>對象。（Student類和Teacher類不存在繼承關(guān)系）顯然，這種情況下，子類型限定和超類型限定都不能用。這時我們可以用這樣一條語句搞定它：

Pair<?>[] pairs = getPairs(...);