本文參考
https://blog.csdn.net/s10461/article/details/53941091
https://juejin.im/post/5e61fb10e51d4526d6406cb0
https://www.jianshu.com/p/71a5d70c180e
https://blog.csdn.net/xx326664162/article/details/52175283
1、泛型的定義與作用
泛型，即“參數化類型”。一提到參數，最熟悉的就是定義方法時有形參，然後調用此方法時傳遞實參。那麼參數化類型怎麼理解呢？顧名思義，就是將類型由原來的具體的類型參數化，類似於方法中的變量參數，此時類型也定義成參數形式（可以稱之爲類型形參），然後在使用/調用時傳入具體的類型（類型實參）。
泛型的本質是爲了參數化類型（在不創建新的類型的情況下，通過泛型指定的不同類型來控制形參具體限制的類型）。也就是說在泛型使用過程中，操作的數據類型被指定爲一個參數，這種參數類型可以用在類、接口和方法中，分別被稱爲泛型類、泛型接口、泛型方法。
2、泛型的例子
泛型只在編譯階段有效
List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();
Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();
if(classStringArrayList.equals(classIntegerArrayList)){
Log.d("泛型測試","類型相同");
}
上述代碼會打印出結果。在編譯之後程序會採取去泛型化的措施。也就是說Java中的泛型，只在編譯階段有效。在編譯過程中，正確檢驗泛型結果後，會將泛型的相關信息擦出，並且在對象進入和離開方法的邊界處添加類型檢查和類型轉換的方法。也就是說，泛型信息不會進入到運行時階段
3. 泛型的使用
泛型有三種使用方式，分別爲：泛型類、泛型接口、泛型方
4. 類型通配符
public void showKeyValue1(Generic<?> obj){
Log.d("泛型測試","key value is " + obj.getKey());
}
類型通配符一般是使用？代替具體的類型實參，注意了，此處’？’是類型實參，而不是類型形參 。重要說三遍！此處’？’是類型實參，而不是類型形參 ！ 此處’？’是類型實參，而不是類型形參 ！再直白點的意思就是，此處的？和Number、String、Integer一樣都是一種實際的類型，可以把？看成所有類型的父類。是一種真實的類型。
可以解決當具體類型不確定的時候，這個通配符就是 ? ；當操作類型時，不需要使用類型的具體功能時，只使用Object類中的功能。那麼可以用 ? 通配符來表未知類型。
5. 泛型方法
5.1 泛型類，是在實例化類的時候指明泛型的具體類型；泛型方法，是在調用方法的時候指明泛型的具體類型 。
/**
* 泛型方法的基本介紹
* @param tClass 傳入的泛型實參
* @return T 返回值爲T類型
* 說明：
* 1）public 與 返回值中間<T>非常重要，可以理解爲聲明此方法爲泛型方法。
* 2）只有聲明瞭<T>的方法纔是泛型方法，泛型類中的使用了泛型的成員方法並不是泛型方法。
* 3）<T>表明該方法將使用泛型類型T，此時纔可以在方法中使用泛型類型T。
* 4）與泛型類的定義一樣，此處T可以隨便寫爲任意標識，常見的如T、E、K、V等形式的參數常用於表示泛型。
*/
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
IllegalAccessException{
T instance = tClass.newInstance();
return instance;
}
5.2 泛型方法的基本用法
public class GenericTest {
//這個類是個泛型類，在上面已經介紹過
public class Generic<T>{
private T key;
public Generic(T key) {
this.key = key;
}
//我想說的其實是這個，雖然在方法中使用了泛型，但是這並不是一個泛型方法。
//這只是類中一個普通的成員方法，只不過他的返回值是在聲明泛型類已經聲明過的泛型。
//所以在這個方法中才可以繼續使用 T 這個泛型。
public T getKey(){
return key;
}
/**
* 這個方法顯然是有問題的，在編譯器會給我們提示這樣的錯誤信息"cannot reslove symbol E"
* 因爲在類的聲明中並未聲明泛型E，所以在使用E做形參和返回值類型時，編譯器會無法識別。
public E setKey(E key){
this.key = keu
}
*/
}
/**
* 這纔是一個真正的泛型方法。
* 首先在public與返回值之間的<T>必不可少，這表明這是一個泛型方法，並且聲明瞭一個泛型T
* 這個T可以出現在這個泛型方法的任意位置.
* 泛型的數量也可以爲任意多個
* 如：public <T,K> K showKeyName(Generic<T> container){
* ...
* }
*/
public <T> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
//當然這個例子舉的不太合適，只是爲了說明泛型方法的特性。
T test = container.getKey();
return test;
}
//這也不是一個泛型方法，這就是一個普通的方法，只是使用了Generic<Number>這個泛型類做形參而已。
public void showKeyValue1(Generic<Number> obj){
Log.d("泛型測試","key value is " + obj.getKey());
}
//這也不是一個泛型方法，這也是一個普通的方法，只不過使用了泛型通配符?
//同時這也印證了泛型通配符章節所描述的，?是一種類型實參，可以看做爲Number等所有類的父類
public void showKeyValue2(Generic<?> obj){
Log.d("泛型測試","key value is " + obj.getKey());
}
/**
* 這個方法是有問題的，編譯器會爲我們提示錯誤信息："UnKnown class 'E' "
* 雖然我們聲明瞭<T>,也表明了這是一個可以處理泛型的類型的泛型方法。
* 但是隻聲明瞭泛型類型T，並未聲明泛型類型E，因此編譯器並不知道該如何處理E這個類型。
public <T> T showKeyName(Generic<E> container){
...
}
*/
/**
* 這個方法也是有問題的，編譯器會爲我們提示錯誤信息："UnKnown class 'T' "
* 對於編譯器來說T這個類型並未在項目中聲明過，因此編譯也不知道該如何編譯這個類。
* 所以這也不是一個正確的泛型方法聲明。
public void showkey(T genericObj){
}
*/
public static void main(String[] args) {
}
}
5.3 類中的泛型方法
當然這並不是泛型方法的全部，泛型方法可以出現雜任何地方和任何場景中使用。但是有一種情況是非常特殊的，當泛型方法出現在泛型類中時，我們再通過一個例子看一下
public class GenericFruit {
class Fruit{
@Override
public String toString() {
return "fruit";
}
}
class Apple extends Fruit{
@Override
public String toString() {
return "apple";
}
}
class Person{
@Override
public String toString() {
return "Person";
}
}
class GenerateTest<T>{
public void show_1(T t){
System.out.println(t.toString());
}
//在泛型類中聲明瞭一個泛型方法，使用泛型E，這種泛型E可以爲任意類型。可以類型與T相同，也可以不同。
//由於泛型方法在聲明的時候會聲明泛型<E>，因此即使在泛型類中並未聲明泛型，編譯器也能夠正確識別泛型方法中識別的泛型。
public <E> void show_3(E t){
System.out.println(t.toString());
}
//在泛型類中聲明瞭一個泛型方法，使用泛型T，注意這個T是一種全新的類型，可以與泛型類中聲明的T不是同一種類型。
public <T> void show_2(T t){
System.out.println(t.toString());
}
}
public static void main(String[] args) {
Apple apple = new Apple();
Person person = new Person();
GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
//apple是Fruit的子類，所以這裏可以
generateTest.show_1(apple);
//編譯器會報錯，因爲泛型類型實參指定的是Fruit，而傳入的實參類是Person
//generateTest.show_1(person);
//使用這兩個方法都可以成功
generateTest.show_2(apple);
generateTest.show_2(person);
//使用這兩個方法也都可以成功
generateTest.show_3(apple);
generateTest.show_3(person);
}
}
5.4 泛型方法和可變參數
舉例子：
public <T> void printMsg( T... args){
for(T t : args){
Log.d("泛型測試","t is " + t);
}
}
printMsg("111",222,"aaaa","2323.4",55.55);
5.5 靜態方法與泛型
靜態方法無法訪問類上定義的泛型；如果靜態方法操作的引用數據類型不確定的時候，必須要將泛型定義在方法上。
即：如果靜態方法要使用泛型的話，必須將靜態方法也定義成泛型方法 。
public class StaticGenerator<T> {
....
....
/**
* 如果在類中定義使用泛型的靜態方法，需要添加額外的泛型聲明（將這個方法定義成泛型方法）
* 即使靜態方法要使用泛型類中已經聲明過的泛型也不可以。
* 如：public static void show(T t){..},此時編譯器會提示錯誤信息：
"StaticGenerator cannot be refrenced from static context"
*/
public static <T> void show(T t){
}
}
5.6 泛型上下邊界
爲泛型添加上邊界，即傳入的類型實參必須是指定類型的子類型
public void showKeyValue1(Generic<? extends Number> obj){
Log.d("泛型測試","key value is " + obj.getKey());
}
6. 協變, 逆變
java中協變跟逆變是對泛型類的繼承關係的表述.
如上面5.6提到的泛型上下邊界問題。這裏拓展一下：
java中協變跟逆變是對泛型類的繼承關係的表述.
如: List<Number> 和List<Integer> 之間是沒有繼承關係的.
但是直觀上會覺得, Integer 是Number 的子類, 所以List<Integer> 應是List<Number> 的子類.
如果想要這種效果, 就要用協變. List<? extends Number> 這樣 List<Integer> 就能成爲List<? extends Number> 子類, 也就是可以賦值
List<Integer>b = new ArrayList<>();
List<? extends Number> a = b;
這裏如果你想要相反的效果, 則用逆變,List<? super Number> 這樣繼承關係就會相反.
總結
extends限定了通配符類型的上界，所以我們可以安全地從其中讀取；而super限定了通配符類型的下界，所以我們可以安全地向其中寫入。
我們可以把那些只能從中讀取的對象稱爲生產者（Producer），我們可以從生產者中安全地讀取；只能寫入的對象稱爲消費者（Consumer）。因此可以這麼說：Producer-Extends, Consumer-Super。