泛型是什麼？

泛型，即“引數化型別”。一提到引數，最熟悉的就是定義方法時有形參，然後呼叫此方法時傳遞實參。那麼引數化型別怎麼理解呢？顧名思義，就是將型別由原來的具體的型別引數化，類似於方法中的變數引數，此時型別也定義成引數形式（可以稱之為型別形參），然後在使用/呼叫時傳入具體的型別（型別實參）。

泛型的本質是為了引數化型別（在不建立新的型別的情況下，通過泛型指定的不同型別來控制形參具體限制的型別）。也就是說在泛型使用過程中，操作的資料型別被指定為一個引數，這種引數型別可以用在類、介面和方法中，分別被稱為泛型類、泛型介面、泛型方法。

在集合中儲存物件並在使用前進行型別轉換是多麼的不方便。泛型防止了那種情況的發生。它提供了編譯期的型別安全，確保你只能把正確型別的物件放入 集合中，避免了在執行時出現ClassCastException。

優點

泛型的引入可以解決之前的集合類框架在使用過程中通常會出現的執行時刻型別錯誤，因為編譯器可以在編譯時刻就發現很多明顯的錯誤。

型別擦除

泛型實在編譯器層次來實現的

在生成的java位元組程式碼中是不包含泛型中的型別資訊的。使用泛型的時候加上的型別引數，會被編譯器在編譯的時候去掉，這個就叫型別擦除。

如在程式碼中定義的List（Object）和List（String）等型別，在編譯之後都會變成List。JVM看到的只是List，而由泛型附加的型別資訊對JVM來說是不可見的，java編譯器會在編譯是儘可能發現出錯的地方，但是仍然無法避免在執行時刻出現型別轉換異常的情況。

泛型的奇怪特性都與型別擦除有關

1. 泛型類並沒有自己獨有的Class物件，比如並不存在List(String).class,z只有List.class
2. 靜態變數是被泛型類的所有例項被共享的。對於宣告為MyClass（T）的類，訪問其中的靜態變數的方法仍然是 MyClass.myStaticVar。不管是通過new MyClass（String）還是new MyClass（Integer）建立的物件，都是共享一個靜態變數。
3. 泛型的型別引數不能用在java異常處理的catch語句中。因為異常處理是由JVM在執行時刻來進行的。由於型別資訊被擦除，JVM是無法區分兩個異常型別MyException（String）和MyException（Integer）的。對於JVM來說，它們都是 MyException型別的。也就無法執行與異常對應的catch語句。

型別擦除過程

找到用來替換型別引數的具體類。這個具體類一般是Object。如果指定了型別引數的上界的話，則使用上界。把程式碼中的型別引數都替換成具體類。同時去掉同時出現的型別宣告，即去掉<>的內容。比如Tget(）方法宣告就變成了Object get()；List（String）就變成了List。接下來就可能需要生辰改一些橋接方法。就是由於擦除了型別之後的類可能缺少默寫某些必須的方法。這樣做的目的，是確保能和Java 5之前的版本開發二進位制類庫進行相容。你無法在執行時訪問到型別引數，因為編譯器已經把泛型型別轉換成了原始型別。

例項分析

public void insert(List（Object) list) {    
    for (Object obj : list) {        
        System.out.println(obj);    
    }    
    list.add(1); //這個操作在當前方法的上下文是合法的。 
}
public void test() {    
    List（String） strs = new ArrayList（String）();    
    inspect(strs); //編譯錯誤 
}複製程式碼

泛型類

public class Som<T> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}
複製程式碼

Som就是一個泛型類，value的型別是T，而T是引數化的。如果有多個型別引數，使用分號隔開,如<U,V>。在編譯期，是無法知道U和V具體是什麼型別，只有在執行時才會真正根據型別來構造和分配記憶體。

public class Main {
    public static void main(String[] args) {
        Son<String, String> c1 = new Son<String, String>("name", "findingsea");
        Son<String, Integer> c2 = new Son<String, Integer>("age", 24);
        Son<Double, Double> c3 = new Son<Double, Double>(1.1, 2.2);
        System.out.println(c1.getKey() + " : " + c1.getValue());
        System.out.println(c2.getKey() + " : " + c2.getValue());
        System.out.println(c3.getKey() + " : " + c3.getValue());
    }
}輸出：

name : findingsea
age : 24
1.1 : 2.2複製程式碼

可以看一下現在Som類對於不同型別的支援情況：
使用泛型類：

Som<String> som = new Som<>();
som.setValue("Hi");
//som.setValue(123);編譯不通過
String str = som.getValue();
複製程式碼

在使用中指定具體的型別實參。

泛型介面

public interface Generator<T> {
    public T next();
}
然後定義一個生成器類來實現這個介面：

public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}
呼叫：

public class Main {

    public static void main(String[] args) {
        FruitGenerator generator = new FruitGenerator();
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
    }
}
輸出：

Apple
Banana
Pear
Pear複製程式碼

泛型方法

在java中,泛型類的定義非常簡單，但是泛型方法就比較複雜了。無論何時，只要你能做到，你就應該儘量使用泛型方法。也就是說，如果使用泛型方法可以取代將整個類泛化，那麼應該有限採用泛型方法。

泛型類，是在例項化類的時候指明泛型的具體型別；泛型方法，是在呼叫方法的時候指明泛型的具體型別 。

如果你定義了一個泛型（類、介面），那麼Java規定，你不能在所有的靜態方法、靜態初塊等所有靜態內容中使用泛型的型別引數。例如：

public class A<T> {
    public static void func(T t) {
    //報錯，編譯不通過
    }
}複製程式碼

泛型的萬用字元

泛型的萬用字元增強了方法的靈活性但也容易讓人困惑。

public static void printList(List<?> list) {
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}
複製程式碼

public static void printList(List<? extends Number> list) {
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}
複製程式碼

public static void printList(List<?> list) {
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    //一下操作不可以
    list.add(1);
    list.add("123");
}
複製程式碼

public static void printList(List<? super String> list) {
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    list.add("123");
    list.add("456");
}
複製程式碼

Som<String> [] soms = new Som<String>[8];
複製程式碼

Som<Integer>[] soms = new Som<Integer>[3];
Object[] objs = soms;
objs[0] = new Som<String>();
複製程式碼