摘要：引用泛型除了方法因不能使用外部實例參數外，其他繼承實現成員變量，成員方法，方法返回值等都可使用。因此，生成的字節碼僅包含普通的類，接口和方法。

一般的類和方法，只能使用具體的類型：要么是基本類型，要么是自定義類的對應類型；如果要編寫可以應用于多種類型的代碼，這種刻板的限制對代碼的束縛就會很大。
----摘自原書
Ordinary classes and methods work with specific types: either
primitives or class types. If you are writing code that might be used
across more types, this rigidity can be overconstraining.
----摘自英文版

從原書的第一段話引出，其實泛型的出現是為了讓編寫的代碼可以應用于多種類型，解除只能使用具體類型的限制，這也就是參數化類型的概念。

泛型是在Java SE5出現的，也就是說java5版本之前的java是不存在泛型的概念的。而Java5這個版本增加了泛型設計其中重要的一個原因就是：優雅的安全的讓容器類解除只能使用具體類型的束縛，從而適用于多種類型。

下面以ArrayList為例比較前后差異，證明泛型的優雅和安全：

java1.4版本

public class ArrayList // 省略繼承和實現
{
    transient Object[] elementData;         // 用于存儲ArrayList對象的數組
    public Object get(int index) { . . . }  // 獲取數組對象
    public void add(Object o) { . . . }     // 添加數組對象
}

java5版本

public class ArrayList
{
    transient Object[] elementData;
    public E get(int index) {...}
    public boolean add(E e) {...}

從兩者對比可以看出，java1.4版本是使用Object類作為對象存取的的出參入參，這樣的好處自然是可以讓ArrayList類滿足編寫一次適用于多種類型的代碼設計，可是這樣就暴露以下幾個問題了：

當獲取一個值時必須進行強制類型轉換

ArrayList strs = new ArrayList();
strs.add("hello");
String str = (String) strs.get(0);

這里如果不加(String)強制轉換，那么代碼在編譯期就會報錯：Incompatible types，并提示files.get(0)返回的是一個Object對象可是接收的是String類型對象，需要做類型強制轉換。

當添加一個值時沒有在編譯器做類型錯誤檢査

ArrayList files = new ArrayList();
files.add(new File("./hello.text"));
File file = (File)files.get(0);     // 正常
String file = (String)files.get(0); // 編譯器正常，運行期報錯

代碼在編譯期不會出錯，可是在運行期的時候就會報強轉錯誤：java.lang.ClassCastException，這個問題其實也就是使用Object類的弊端了。

既然java1.4出現了上述問題，那么現在就是用java5版本的泛型來解決上述的問題，如下：

當獲取一個值時必須進行強制類型轉換（解決）

// 這里第二個<>省略了String，是因為類型推導
ArrayList strs = new ArrayList<>();
strs.add("hello");
String str = strs.get(0);

可以看出java5之后之后就不需要做類型強轉了，這是因為get方法的返回類型已經在實例化的時候被給參數化了。

當添加一個值時沒有在編譯器做類型錯誤檢査（解決）

ArrayList files = new ArrayList<>();
files.add(new File("./../Fibonacci.java"));
File file = (File)files.get(0);             // 正常
String file = (String)files.get(0);         // 編譯期就報錯了

可以看出1.5之后之后就不需要可能到線上才會發現的bug，在編寫代碼的時候編輯器就給提前給提示：Inconvertible types; cannot cast "java.io.File" to "java.lang.String"(禁止File類型轉換成String類型了)

雖然泛型解決的問題還有很多，但是總的來說都是為了：更優雅的更安全的讓容器類解除只能使用具體類型的束縛，從而適用于多種類型。

下面我們就來正式講一下泛型的語法，以及使用范圍：

語法定義：

定義泛型：接口名之后定義該類會使用到的所有泛型。

引用泛型：除了static方法因不能使用外部實例參數外，其他繼承、實現、成員變量，成員方法等都可使用。

泛型實參：通過繼承類的實例化時傳入，不傳默認是Object

語法結構：

interface  接口名 <定義泛型標識> extends 父接口名 <引用泛型標識> {
  public 引用泛型標識 var; 
  ...
}

案例 —— 生成器接口：

/**
 * 生成器是一種專門負責創建對象的類，是類似工廠模式，不同的是工廠模式一般需要入參，而生成器不需要。
 * 即生成器是：無需額外的信息就可以知道如何創建對象，一般來說生成器只會定義一個創建對象的方法。
 * 本例子中的創建對象方法就是next
 * @param 
 */
public interface Generator {
  T next();
}

語法定義：

定義泛型：類名之后定義該類會使用到的所有泛型。

引用泛型：除了static方法因不能使用外部實例參數外，其他繼承、實現、成員變量，成員方法，方法返回值等都可使用。

泛型實參：類的實例化時鉆石符放在類名之后，如：new ArrayList()

語法結構：

class  類名 <定義泛型標識> 
    extends 父類名 <引用泛型標識>, implements 接口名 <引用泛型標識> {
  private 引用泛型標識 var; 
  ...
}

案例 —— 生成器具體實現類:

public class TestBasicGenerator implements Generator {
  private Class type = null;
  // 本來下面寫法會更優雅一點，但是因為泛型的類型擦除導致這種寫法是會報錯的
  // private Class type = T.class;
  public TestBasicGenerator(Class clazz) {
    type = clazz;
  }
  public static  Generator gen(Class clazz) {
    return new TestBasicGenerator(clazz);
  }
  public T next() {
    try {
      return (T) type.newInstance();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  public static void main(String[] args) {
    // 書上的方法，通過靜態泛型方法：簡單
    Generator gen = TestBasicGenerator.gen(Coffee.class);
    Coffee c =  gen.next();

    // 課后習題，通過實例化方法：復雜
    Generator gen1 = new TestBasicGenerator(Coffee.class);
    Coffee c1 =  gen1.next();
  }
}

語法定義：

定義泛型：該方法修飾符之后定義該方法會使用到的所有泛型。

引用泛型：包括返回值、參數、內部變量，內部方法等，除非該方法是static方法，否則也可以使用類上定義的泛型，兩者不沖突。

泛型實參：

顯示傳遞：方法調用時鉆石符放在方法名之前，"."號之后，如：New.show("hello")，一般建議用顯示傳遞，方便閱讀。

隱式傳遞：無需傳遞，編譯器會根據上下文（入參或者返回值接收變量）推導出具體的類型，如：New.show("hello")、Map> sls = New.map()（前者根據是非賦值語句的入參推導，后者根據賦值語句的接收變量推導）。

語法結構：

public class 類名 {
    public <定義泛型標識> 返回類型 方法名(引用泛型標識 形參名) {
        ...
    }
}

案例 —— 創建常用容器對象的工具類（簡略版）：

public class New {
  public static  Map map() {
          return new HashMap();
  }
  public static  void show(T title) {
          System.out.println(title);
  }
    // Examples:
  public static void main(String[] args) {
    Map> sls = New.map();
    // 顯示傳遞
    New.show("hello");
    // 隱式傳遞
    New.show("hello");
    // 編譯器會報show方法不能傳遞String類型，證明顯示傳遞為主，隱式傳遞為輔
    New.show("hello");
  }
}

可變參數方法可以與泛型無縫結合：

案例 —— 入參聚合:

public class GenericVarargs {
  public static  List makeList(T... args) {
    List result = new ArrayList();
    for(T item : args)
      result.add(item);
    return result;
  }
  public static void main(String[] args) {
    ls = makeList("A", "B", "C");
    System.out.println(ls);    // 打印出：[A, B, C]
  }
}

有時您可能希望在泛型類、泛型方法、泛型接口中限制一下傳入的泛型實參的類型。例如，對數字進行操作的方法可能只想接受Number子類或者父類的實例，那這個時候就需要用到邊界通配符了：

使用上界限制類型參數，需要借助extends關鍵之，先在<>中寫類型參數的標志號，后跟extends，最后才是上界類型（注意：上界類型可以多個，但是最多只允許一個類搭配多個接口，類還必須寫在第一位，因為java是單繼承多實現），用法一般只用于泛型方法、泛型接口、泛型類這三處語法中的定義泛型的地方。

復雜案例如下（僅做案例）：

// 表示類型實參只能是Number的子類，并且該子類還要實現List接口，否則編譯報錯（上界不包含上）
public class TestTypeErasure> {
    ...
}

上界通配符

使用下屆限制類型參數，需要借助super關鍵之，先在<>中寫無界通配符?，后跟super，最后才是下屆具體類型或泛型標識符（注意：這里就只能一個了），用法一般只用于限制容器類值。

復雜案例如下（僅做案例）：

// 表示類型實參可以是Integer類型，或者Integer的父類（下屆包含下）
public static void addNumbers(List list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}

上面講下屆通配符時需要借助無界通配符，但是它不止有哪一種寫法，還可以直接在<>中寫?，表示不限定類型參數，類似