泛型是什麼？
考慮以下場景：您希望開發一個用於在應用中傳遞物件的容器。但物件型別並不總是相同。因此，需要開發一個能夠儲存各種型別物件的容器。
鑑於這種情況，要實現此目標，顯然最好的辦法是開發一個能夠儲存和檢索 Object 型別本身的容器，然後在將該物件用於各種型別時進行型別轉換。
例項1中的類演示瞭如何開發此類容器。
public class ObjectContainer {
private Object obj;
/**
* @return the obj
*/
public Object getObj() {
return obj;
}
/**
* @param obj the obj to set
*/
public void setObj(Object obj) {
this.obj = obj;
}
}
ObjectContainer myObj = new ObjectContainer();
// store a string
myObj.setObj("Test");
System.out.println("Value of myObj:" + myObj.getObj());
// store an int (which is autoboxed to an Integer object)
myObj.setObj(3);
System.out.println("Value of myObj:" + myObj.getObj());
List objectList = new ArrayList();
objectList.add(myObj);
// We have to cast and must cast the correct type to avoid ClassCastException!
String myStr = (String) ((ObjectContainer)objectList.get(0)).getObj();
System.out.println("myStr: " + myStr);
複製程式碼雖然這個容器會達到預期效果，但就我們的目的而言，它並不是最合適的解決方案。
它不是型別安全的，並且要求在檢索封裝物件時使用顯式型別轉換，因此有可能引發異常。
使用泛型可以開發一個更好的解決方案，在例項化時為所使用的容器分配一個型別，也稱泛型型別，這樣就可以建立一個物件來儲存所分配型別的物件。
泛型型別是一種型別引數化的類或介面，這意味著可以通過執行泛型型別呼叫 分配一個型別，將用分配的具體型別替換泛型型別。然後，所分配的型別將用於限制容器內使用的值，這樣就無需進行型別轉換，還可以在編譯時提供更強的型別檢查。
例項2演示瞭如何建立與先前建立的容器相同的容器，但這次使用泛型型別引數，而不是 Object 型別。
public class GenericContainer<T> {
private T obj;
public GenericContainer(){
}
// Pass type in as parameter to constructor
public GenericContainer(T t){
obj = t;
}
/**
* @return the obj
*/
public T getObj() {
return obj;
}
/**
* @param obj the obj to set
*/
public void setObj(T t) {
obj = t;
}
}
//要使用泛型容器，必須在例項化時使用尖括號表示法指定容器型別。
//因此，以下程式碼將例項化一個 Integer 型別的GenericContainer，並將其分配給 myInt 欄位。
GenericContainer<Integer> myInt = new GenericContainer<>();
//或者
GenericContainer<Integer> myInt = new GenericContainer<Integer>();
//如果我們嘗試在已經例項化的容器中儲存其他型別的物件，程式碼將無法編譯
myInt.setObj(3); // OK
myInt.setObj("Int"); // Won't Compile
複製程式碼最顯著的差異是類定義包含 ，類欄位 obj 不再是 Object 型別，而是泛型型別 T。類定義中的尖括號之間是型別引數部分，介紹類中將要使用的型別引數（或多個引數）。T 是與此類中定義的泛型型別關聯的引數。
使用泛型的好處
一個
最重要的好處是更強的型別檢查，因為避開執行時可能引發的 ClassCastException 可以節省時間。
另一個好處是
消除了型別轉換，這意味著可以用更少的程式碼，因為編譯器確切知道集合中儲存的是何種型別。
如何使用泛型
泛型有許多不同用例。本文在前面的示例中介紹了生成泛型物件型別的用例。這對於在類和介面層面瞭解泛型語法是個很好的起點。
類簽名包含一個型別引數部分，包括在類名後的尖括號 (< >) 內
例如：
public class GenericContainer<T> {
...
複製程式碼
型別引數（又稱型別變數）用作佔位符，指示在執行時為類分配型別。根據需要，可能有一個或多個型別引數，並且可以用於整個類。根據慣例，型別引數是單個大寫字母，該字母用於指示所定義的引數型別。下面列出每個用例的標準型別引數：
- E：元素
- K：鍵
- N：數字
- T：型別
- V：值
- S、U、V 等：多引數情況中的第 2、3、4 個型別
在上面的示例中，T 指示將分配的型別，因此可在例項化時為 GenericContainer 分配任何有效型別。注意，T 引數用於整個類，指示例項化時指定的型別。使用下面這行程式碼例項化物件時，將用 String 型別替換所有 T 引數：
GenericContainer<String> stringContainer = new GenericContainer<String>();
複製程式碼泛型也可用於建構函式中，傳遞類域初始化所需的型別引數。GenericContainer 的建構函式允許在例項化時傳遞任意型別：
GenericContainer gc1 = new GenericContainer(3);
GenericContainer gc2 = new GenericContainer("Hello");
複製程式碼注意，未分配型別的泛型稱為原始型別。例如，要建立原始型別的 GenericContainer，可以使用以下程式碼：
GenericContainer rawContainer = new GenericContainer();
複製程式碼原始型別有時對於實現向後相容很有用，但並不適用於日常程式碼。原始型別在編譯時無需執行型別檢查，導致程式碼在執行時易於出錯。
多種泛型型別
有時，能夠在類或介面中使用多種泛型型別很有幫助。通過在尖括號之間放置一個逗號分隔的型別列表，可在類或介面中使用多個型別引數。
下面例項中的類使用一個接受以下兩種型別的類演示了此概念：T 和 S。
public class MultiGenericContainer<T, S> {
private T firstPosition;
private S secondPosition;
public MultiGenericContainer(T firstPosition, S secondPosition){
this.firstPosition = firstPosition;
this.secondPosition = secondPosition;
}
public T getFirstPosition(){
return firstPosition;
}
public void setFirstPosition(T firstPosition){
this.firstPosition = firstPosition;
}
public S getSecondPosition(){
return secondPosition;
}
public void setSecondPosition(S secondPosition){
this.secondPosition = secondPosition;
}
}
複製程式碼MultiGenericContainer 類可用於儲存兩個不同物件，每個物件的型別可在例項化時指定。
容器的用法如下
MultiGenericContainer<String, String> mondayWeather =
new MultiGenericContainer<String, String>("Monday", "Sunny");
MultiGenericContainer<Integer, Double> dayOfWeekDegrees =
new MultiGenericContainer<Integer, Double>(1, 78.0);
String mondayForecast = mondayWeather.getFirstPosition();
// The Double type is unboxed--to double, in this case. More on this in next section!
double sundayDegrees = dayOfWeekDegrees.getSecondPosition();
複製程式碼有界型別
我們經常會遇到這種情況，需要指定泛型型別，但又希望可以控制指定的型別，而非不加限制。有界型別 在型別引數部分指定 extends 或 super 關鍵字，分別用上限或下限限制型別，從而限制泛型型別的邊界。
如果希望將某型別限制為特定型別或特定型別的子型別，請使用以下表示法：
<T extends UpperBoundType>
複製程式碼同樣，如果希望將某個型別限制為特定型別或特定型別的超型別，請使用以下表示法：
<T super LowerBoundType>
複製程式碼什麼是PECS？
PECS指“Producer Extends，Consumer Super”。 如果你是想遍歷collection，並對每一項元素操作時，此時這個集合是生產者（生產元素），應該使用 Collection<? extends Thing>。 如果你是想新增元素到collection中去，那麼此時集合是消費者（消費元素）應該使用Collection<? super Thing>。
泛型方法
有時，我們可能不知道傳入方法的引數型別。在方法級別應用泛型可以解決此類問題。方法引數可以包含泛型型別，方法也可以包含泛型返回型別。
假設我們要開發一個接受 Number 型別的計算器類。泛型可用於確保可將任何 Number 型別作為引數傳遞給此類的計算方法。
例如，如下示例中的 add() 方法演示瞭如何使用泛型限制兩個引數的型別，確保其包含 Number 的上限：
public static <N extends Number> double add(N a, N b){
double sum = 0;
sum = a.doubleValue() + b.doubleValue();
return sum;
}
複製程式碼通過將型別限制為 Number，您可以將 Number 子類的任何物件作為引數傳遞。此外，通過將型別限制為 Number，我們還可以確保傳遞給該方法的任何引數將包含 doubleValue() 方法。要檢視實際效果，如果您想新增一個 Integer 和一個 Float，可以按如下所示呼叫該方法：
double genericValue1 = Calculator.add(3, 3f);
複製程式碼萬用字元
某些情況下，編寫指定未知型別的程式碼很有用。問號 ? 萬用字元可用於使用泛型程式碼表示未知型別。萬用字元可用於引數、欄位、區域性變數和返回型別。但最好不要在返回型別中使用萬用字元，因為確切知道方法返回的型別更安全。
假設我們想編寫一個方法來驗證指定的 List 中是否存在指定的物件。我們希望該方法接受兩個引數：一個是未知型別的 List，另一個是任意型別的物件。
public static <T> void checkList(List<?> myList, T obj){
if(myList.contains(obj)){
System.out.println("The list contains the element: " + obj);
} else {
System.out.println("The list does not contain the element: " + obj);
}
}
複製程式碼使用示例
// Create List of type Integer
List<Integer> intList = new ArrayList<Integer>();
intList.add(2);
intList.add(4);
intList.add(6);
// Create List of type String
List<String> strList = new ArrayList<String>();
strList.add("two");
strList.add("four");
strList.add("six");
// Create List of type Object
List<Object> objList = new ArrayList<Object>();
objList.add("two");
objList.add("four");
objList.add(strList);
checkList(intList, 3);
// Output: The list [2, 4, 6] does not contain the element: 3
checkList(objList, strList);
/* Output: The list [two, four, [two, four, six]] contains
the element: [two, four, six] */
checkList(strList, objList);
/* Output: The list [two, four, six] does not contain
the element: [two, four, [two, four, six]] */
複製程式碼有時要使用上限或下限限制萬用字元。與指定帶邊界的泛型型別極其相似，指定 extends 或 super 關鍵字加上萬用字元，後面跟用於上限或下限的型別，即可宣告帶邊界的萬用字元型別。
例如，如果我們要更改 checkList 方法使其只接受擴充套件 Number 型別的 List，可按清單 14 所示編寫程式碼。
public static <T> void checkNumber(List<? extends Number> myList, T obj){
if(myList.contains(obj)){
System.out.println("The list " + myList + " contains the element: " + obj);
} else {
System.out.println("The list " + myList + " does not contain the
element: " + obj);
}
}
複製程式碼總結
泛型其實說白了就是應用在編譯時期，是給編譯器使用的技術，到了執行時期，泛型就不存在啦。這是因為，編輯器檢查了泛型的型別正確之後，再生成的類檔案中是沒有泛型的。
泛型使用注意事項
- 物件例項化時不指定泛型的話，預設為：Object。
泛型的指定中不能使用基本資料型別，可以使用包裝類替換。靜態方法中不能使用類的泛型- 可以同時繫結多個繫結,用
&連線 - 泛型類可能多個引數，此時應將多個引數一起放在尖括號內。比如<E1,E2,E3>
- 從泛型類派生子類，泛型型別需具體化：繼承泛型類後，子類型別對應型別需要具體化
- 如果泛型類是一個介面或抽象類，則不可建立泛型類的物件。