前言

Java 5 添加了泛型，提供了編譯時類型安全檢測機制，該機制允許程序員在編譯時檢測到非法的類型。
泛型的本質是參數化類型，可以爲以前處理通用對象的類和方法，指定具體的對象類型。聽起來有點抽象，所以我們將馬上看一些泛型用在集合上的例子：

泛型集合

先看一個沒有泛型的集合例子：

List list = new ArrayList();
list.add(new Integer(2));
list.add("a String");

因爲 List 可以添加任何對象，所以從 List 中取出的對象時，因爲不確定（List不記住元素類型）當時候保存進 List 的元素類型，這個對象的類型只能是 Object ，還必須由程序編寫者記住添加元素類型，然後取出時再進行強制類型轉換就，如下：

Integer integer = (Integer) list.get(0);
String string   = (String) list.get(1);

通常，我們只使用帶有單一類型元素的集合，並且不希望其他類型的對象被添加到集合中，例如，只有 Integer 的 List ，不希望將 String 對象放進集合，並且也不想自己記住元素類型，並且強制類型轉換還可能會出現錯誤。

使用 Generics（泛型）就可以設置集合的類型，以限制可以將哪種對象插入集合中。這可以確保集合中的元素，都是同一種已知類型的，因此取出數據的時候就不必進行強制類型轉換了，一下是一個 String 類型的 List 的使用例子：

List<String> strings = new ArrayList<String>();
strings.add("a String");
String aString = strings.get(0);

以上這個 List 集合只能放入 String 對象，如果視圖放入別的對象那麼編譯器會報錯，讓代碼編寫者必須進行處理，這就是額外的類型檢查。另外注意List 的 <> 尖括號裏面只能是對象引用類型，不包括基本類型（可以使用對應包裝類代替）。

Java 泛型從 Java 7 開始，編譯器可以自動類型判斷，可以省略構造器中的泛型，下面是一個Java 7 泛型例子：

List<String> strings = new ArrayList<>();

這也叫做菱形語法（<>這個符號是菱形），在上面的示例中，實例化 ArrayList 的時候，表一起根據前面 List 知道 new 的 ArrayList 泛型信息是 String，因此可省略。

foreach 循環可以很好地與泛型集合整合，如下：

List<String> strings = new ArrayList<>();

// 這裏省略將 String 元素添加進集合的代碼...

for(String aString : strings){
  System.out.println(aString);
}

也可以使用泛型迭代器遍歷集合，如下：

List<String> list = new ArrayList<String>;

Iterator<String> iterator = list.iterator();

while(iterator.hasNext()){
  String aString = iterator.next();
}

注意，泛型類型檢查僅在編譯時存在。在運行時，可以使用反射或者其他方式使字符串集合插入其他對象，但這不是一個好主意。

當然泛型不僅僅可以用在集合上，也可以用在其他需要的類上。

泛型類

從上面的內容中，我們已瞭解泛型的大概理念。現在我們開始泛型類的學習。
泛型也可以用在自定義 Java 類上，並不侷限於 Java API 中的預定義類。定義泛型類只需要在類名後緊跟尖括號，其中 T 是類型標識符，也可以是別的，比如 E 、V 等，如下例：

public class GenericFactory<T> {
    Class theClass = null;

    public GenericFactory(Class theClass) {
        this.theClass = theClass;
    }

    public T createInstance() throws Exception {
        return (T) this.theClass.newInstance();
    }
}

其中 Class.newInstance() 方法是反射知識的內容，這裏只要知道此方法用於 theClass 類對象的創建就行。
是一個類型標記，表示這個泛型類在實例化時可以擁有的類型集。下面是一個例子：

GenericFactory<MyClass> factory = new GenericFactory<MyClass>(MyClass.class);
MyClass myClassInstance = factory.createInstance();

GenericFactory<SomeObject> factory1 = new GenericFactory<SomeObject>(SomeObject.class);
SomeObject someObjectInstance = factory1.createInstance();

使用泛型，我們就不必轉換從 factory.createInstance() 方法返回的對象，會自動返回 new GenericFactory 的 <> 尖括號中的類型對象。

泛型方法

一個泛型方法定義如下：

public static <T> T addAndReturn(T element, Collection<T> collection){
    collection.add(element);
    return element;
}

其中 T 是方法返回值，放在方法返回值之前，是所有泛型方法必須有的類型參數聲明，表示這是一個泛型方法，如果沒有只有 T ，那就不是泛型方法，而是泛型類的一個成員方法，就像上面泛型類定義的方法：

    public T createInstance() throws Exception { ... }

這不是一個泛型方法，而是 GenericFactory泛型類的一個成員方法而已，泛型方法必須在方法返回值之前有似於的標記。

注意在泛型方法中，參數有 2 個，第一個是 T 類型的參數，第二個是元素類型爲 T 的 Collection 集合，編譯器會根據實際參數來推斷 T 爲何種類型，如下這樣是完全可行的：

String stringElement = "stringElement";
List<Object> objectList = new ArrayList<Object>();

Object theElement = addAndReturn(stringElement, objectList);

如上，第一個參數爲 String 類型，第二個是 List 類型，貌似兩個 T 是不匹配的，但是這裏編譯器會自動將 String 轉換爲 Object 類型，並將 T 標識爲 Object 。

繼承關係的泛型參數

定義如下類：

public class A { }
public class B extends A { }
public class C extends A { }

新建並初始化如下類對象：

List<A> listA = new ArrayList<A>();
List<B> listB = new ArrayList<B>();

因爲 A 是 B 和 C 類的共同父類，那麼 List 是不是 List 和 List 的共同父類嗎？換句話說，是否可以將 List 引用指向 List 對象呢？或者反過來讓 List 引用指向 List 對象呢？

答案是不可以，第一種情況，父類引用指向子類對象，如將 List 引用指向 List 對象，先假設這是可以的，有如下代碼：

List<A> listA = listB;

這會出現問題，因爲 listA 是 List 類型，它可以放入任何 A 對象作爲元素，可以放入 B 對象，也可以放入 C 對象，但是它實際指向的是一個 List 集合，List 集合中本應該只存儲 B 類對象的，現在卻不可預料地放入了 C 對象，這顯然會引起麻煩，所以這種情況是不允許的。

第二種情況，讓 List 引用指向 List 對象，這樣肯定也是不可以的，因爲已存在的 List 集合中，可能已經存在了 A 類的非 B 類子類對象，如 C 類對象，這樣也不能保證從 List 集合中取出的元素一定就是 B 對象。

但是，確實存在需要使用泛型繼承關係的情況，看如下代碼：

public void processElements(List<A> elements){
   for(A o : elements){
      System.out.println(o.getValue()); // 這裏假設的 A 類存在 getValue() 方法
   }
}

我們希望定義一個類，讓其能處理所有指定類型元素的 List ，如 processElements(List elements) 方法，既可以處理 List ，也可以處理 List ，但是如上所述， List 和 List 根本就不存在任何繼承關係。
這時就可以使用類型通配符如 <?> 來完成此需求。

類型通配符

有 3 中類型通配符用法，如下代碼：

List<?> listUknown = new ArrayList<A>(); // 任何類型元素都可接受
List<? extends A> listUknown = new ArrayList<A>(); // 可接受 A 子類類型元素
List<? super A> listUknown = new ArrayList<A>(); // 可接受 A 父類類型元素

還可以有多個限定，比如限定要同時可比較和可序列化，就可以使用 <T extends Comparable & Serializable>

無邊界類型通配符<?>

List<?> 表示未知類型的 List 。這可以是 List，List 或 List 等。

由於不知道 List 的類型，所以只能從集合中讀取，不能放入新元素，並且只能將讀取的元素視爲 Object 類型，如下例：

public void processElements(List<?> elements){
   for(Object o : elements){
      System.out.println(o);
   }
}

現在 processElements() 方法可以使用任何泛型參數的 List 集合作爲參數，如下：

List<A> listA = new ArrayList<A>();
processElements(listA);

上界類型通配符<? extends A>

這樣將表示可接受的泛型參數，必須是 A 類或者 A 類的子類，A 類就是最大的範圍，所以叫做上界。
定義如下方法：

public void processElements(List<? extends A> elements){
   for(A a : elements){
      System.out.println(a.getValue());
   }
}

這樣，它可以接收 List, List 或 List 集合作爲參數，如下：

List<A> listA = new ArrayList<A>();
processElements(listA);

List<B> listB = new ArrayList<B>();
processElements(listB);

List<C> listC = new ArrayList<C>();
processElements(listC);

processElements(List<? extends A> elements) 方法仍然無法插入元素到列表中，因爲不知道傳入的 List 中的元素的具體類型，它可能是 A, B 或 C 類，如果可以插入，那麼取出來的時候就無法確認，強制轉換就會失敗。

但是可以讀取元素，因爲 List 裏面保存的元素一定是 A 類或其子類對象，轉換成 A 類不會報錯。

下界類型通配符 <? super A>

這樣將表示可接受的泛型參數，必須是 A 類（A 類的子類也屬於 A 類）或者 A 類的父類，A 類就是最小的範圍，所以叫做下界。
當知道 List 中的元素肯定是 A 類或 A 的父類時，可以安全地將 A 類的對象或 A 的子類對象（例如 B 或 C）插入 List 中。下面是一個例子：

public static void insertElements(List<? super A> list){
    list.add(new A());
    list.add(new B());
    list.add(new C());
}

此處插入的所有元素都是 A 類對象或 A 類的父類的對象。由於 B 和 C 都繼承了 A ，如果 A 有一個父類，B 和 C 也將是該父類的對象。

現在可以使用 List 或類型爲 A 的父類調用 insertElements() ，如下類：

List<A> listA = new ArrayList<A>();
insertElements(listA);

List<Object> listObject = new ArrayList<Object>();
insertElements(listObject);

但是，insertElements() 方法無法從 List 中讀取元素，除非它將讀取到的對象強制轉換爲 Object 。調用 insertElements() 時，List 中已經存在的元素可以是 A 類或其父類的任何類型，但不可能確切地知道它是哪個類。由於 Java 所有的類都是 Object 的子類，因此如果將它們轉換爲 Object ，則可以從列表中讀取對象。如下代碼是正確的：

Object object = list.get(0);

但是如下代碼是錯誤的，因爲父類對象不能轉換爲子類對象：

A object = list.get(0);

泛型擦除

Java 的泛型是僞泛型，幾乎僅僅提供編譯時檢查，泛型確保了只要在編譯時不出現錯誤，運行時就不出現強制轉換異常。在編譯完成後，所有的泛型信息都會被擦除掉。List 和 List 等類型在編譯後都會變成 List ，泛型附帶的類型信息對 JVM 是不可見的。

定義 2 個分別處理 List 和 List 元素的 processElements() 函數，代碼如下：

public void processElements(List<String> elements) {
}
public void processElements(List<Integer> elements) {
}

編譯器會報如下錯誤：
Error:(12, 17) java: 名稱衝突: processElements(java.util.List<java.lang.Integer>)和processElements(java.util.List<java.lang.String>)具有相同疑符

意思就是我們定義了 2 個重複的方法，即兩個方法的參數是一樣的，說明雖然泛型參數不一樣，但到底 List 和 List 是一個東西，它們的原始類型是一樣的，都是同一個 List 類對象，可以使用如下代碼驗證：

Class strListClass = new ArrayList<String>().getClass();
Class intListClass = new ArrayList<Integer>().getClass();
System.out.println(strListClass); // class java.util.ArrayList
System.out.println(intListClass); // class java.util.ArrayList
System.out.println(strListClass == intListClass); // ture

原始類型（raw type）就是擦除（crased）掉泛型信息後的真正類型，泛型參數信息會被擦除，運行時最終使用 Object 或具體的限定類。

如 Class strListClass = new ArrayList<String>().getClass(); 編譯後會變成 Class strListClass = new ArrayList().getClass();

Java 爲什麼只把泛型信息留在編譯階段？
Java不能實現真正泛型的原因？ - RednaxelaFX的回答 - 知乎

其他

JDK 文檔中經常能看到 T、K、V、E、N 等類型參數，實際上這些符號隨意選擇使用也是沒問題的，甚至可以使用如 A、B 等，但建議和 JDK 文檔風格保持一致，至少得讓人容易理解。
常見各符號的含義：

T：type
K：key
V：value
E：element
N：Number

泛型數組

在 Java 中不能創建一個確切泛型類型的數組，如下代碼是不允許的：

List<String>[] strLists = new ArrayList<String>[8];

將會報錯：Error:(11, 27) java: 創建泛型數組。

但是使用通配符創建泛型數組是可以的，比如下面代碼是被允許的：

List<?>[] strLists = new ArrayList<?>[8];

爲什麼？
Java爲什麼不支持泛型數組？ - 蝸牛學院的回答 - 知乎

本文參考：
菜鳥教程
 Java Generics Tutorial

Java 泛型學習總結

前言

泛型集合

泛型類

泛型方法

繼承關係的泛型參數

類型通配符

無邊界類型通配符<?>

上界類型通配符<? extends A>

下界類型通配符 <? super A>

泛型擦除

其他

泛型數組

系統學習 Java IO (四)----文件的讀寫和隨機訪問 FileInputStream/FileOutputStream & RandomAccessFile

仿寫一個簡陋的 IOC/AOP 框架 mini-spring

Java 泛型學習總結

Java NIO 學習筆記（七）----NIO/IO 的對比和總結

Java NIO 學習筆記（四）----文件通道和網絡通道

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結