學(xué)習(xí)java的同學(xué)注意了！！！ 學(xué)習(xí)過程中遇到什么問題或者想獲取學(xué)習(xí)資源的話，歡迎加入Java學(xué)習(xí)交流群，群號碼：183993990  我們一起學(xué)Java！

泛型概述

Java泛型（generics）是JDK 5中引入的一個新特性，允許在定義類和接口的時候使用類型參數(shù)（type parameter）。聲明的類型參數(shù)在使用時用具體的類型來替換。

優(yōu)缺點

從好的方面來說，泛型的引入可以解決之前的集合類框架在使用過程中通常會出現(xiàn)的運行時刻類型錯誤，因為編譯器可以在編譯時刻就發(fā)現(xiàn)很多明顯的錯誤。而從不好的地方來說，為了保證與舊有版本的兼容性，Java泛型的實現(xiàn)上存在著一些不夠優(yōu)雅的地方。當(dāng)然這也是任何有歷史的編程語言所需要承擔(dān)的歷史包袱。后續(xù)的版本更新會為早期的設(shè)計缺陷所累。

舉例

List作為形式參數(shù)，那么如果嘗試將一個List的對象作為實際參數(shù)傳進去，卻發(fā)現(xiàn)無法通過編譯。雖然從直覺上來說，Object是String的父類，這種類型轉(zhuǎn)換應(yīng)該是合理的。但是實際上這會產(chǎn)生隱含的類型轉(zhuǎn)換問題，因此編譯器直接就禁止這樣的行為。

類型擦除

正確理解泛型概念的首要前提是理解類型擦除（type erasure）。

Java中的泛型基本上都是在編譯器這個層次來實現(xiàn)的。

在生成的Java字節(jié)代碼中是不包含泛型中的類型信息的。使用泛型的時候加上的類型參數(shù)，會被編譯器在編譯的時候去掉。這個過程就稱為類型擦除。

如在代碼中定義的List和List等類型，在編譯之后都會變成List。JVM看到的只是List，而由泛型附加的類型信息對JVM來說是不可見的。Java編譯器會在編譯時盡可能的發(fā)現(xiàn)可能出錯的地方，但是仍然無法避免在運行時刻出現(xiàn)類型轉(zhuǎn)換異常的情況。類型擦除也是Java的泛型實現(xiàn)方式與C++模板機制實現(xiàn)方式之間的重要區(qū)別。

很多泛型的奇怪特性都與這個類型擦除的存在有關(guān)

1.泛型類并沒有自己獨有的Class類對象。比如并不存在List.class或是List.class，而只有List.class。

2.靜態(tài)變量是被泛型類的所有實例所共享的。對于聲明為MyClass的類，訪問其中的靜態(tài)變量的方法仍然是 MyClass.myStaticVar。不管是通過new MyClass還是new MyClass創(chuàng)建的對象，都是共享一個靜態(tài)變量。

3.泛型的類型參數(shù)不能用在Java異常處理的catch語句中。因為異常處理是由JVM在運行時刻來進行的。由于類型信息被擦除，JVM是無法區(qū)分兩個異常類型MyException和MyException的。對于JVM來說，它們都是 MyException類型的。也就無法執(zhí)行與異常對應(yīng)的catch語句。

類型擦除的過程

類型擦除的基本過程也比較簡單，首先是找到用來替換類型參數(shù)的具體類。這個具體類一般是Object。如果指定了類型參數(shù)的上界的話，則使用這個上界。把代碼中的類型參數(shù)都替換成具體的類。同時去掉出現(xiàn)的類型聲明，即去掉<>的內(nèi)容。比如T get()方法聲明就變成了Object get()；List就變成了List。接下來就可能需要生成一些橋接方法（bridge method）。這是由于擦除了類型之后的類可能缺少某些必須的方法。

實例分析

了解了類型擦除機制之后，就會明白編譯器承擔(dān)了全部的類型檢查工作。編譯器禁止某些泛型的使用方式，正是為了確保類型的安全性。以上面提到的List和List為例來具體分析：

public void inspect(List<Object> list) {        for (Object obj : list) {                System.out.PRintln(obj);        }        list.add(1); //這個操作在當(dāng)前方法的上下文是合法的。 }public void test() {        List<String> strs = new ArrayList<String>();        inspect(strs); //編譯錯誤 }
這段代碼中，inspect方法接受List作為參數(shù)，當(dāng)在test方法中試圖傳入List的時候，會出現(xiàn)編譯錯誤。假設(shè)這樣的做法是允許的，那么在inspect方法就可以通過list.add(1)來向集合中添加一個數(shù)字。這樣在test方法看來，其聲明為List的集合中卻被添加了一個Integer類型的對象。這顯然是違反類型安全的原則的，在某個時候肯定會拋出ClassCastException。因此，編譯器禁止這樣的行為。編譯器會盡可能的檢查可能存在的類型安全問題。對于確定是違反相關(guān)原則的地方，會給出編譯錯誤。當(dāng)編譯器無法判斷類型的使用是否正確的時候，會給出警告信息。
泛型類
容器類應(yīng)該算得上最具重用性的類庫之一。先來看一個沒有泛型的情況下的容器類如何定義：
public class Container {    private String key;    private String value;    public Container(String k, String v) {        key = k;        value = v;    }    public String getKey() {        return key;    }    public void setKey(String key) {        this.key = key;    }    public String getValue() {        return value;    }    public void setValue(String value) {        this.value = value;    }}
Container類保存了一對key-value鍵值對，但是類型是定死的，也就說如果我想要創(chuàng)建一個鍵值對是String-Integer類型的，當(dāng)前這個Container是做不到的，必須再自定義。那么這明顯重用性就非常低。
當(dāng)然，我可以用Object來代替String，并且在Java SE5之前，我們也只能這么做，由于Object是所有類型的基類，所以可以直接轉(zhuǎn)型。但是這樣靈活性還是不夠，因為還是指定類型了，只不過這次指定的類型層級更高而已，有沒有可能不指定類型？有沒有可能在運行時才知道具體的類型是什么？
所以，就出現(xiàn)了泛型。
public class Container<K, V> {    private K key;    private V value;    public Container(K k, V v) {        key = k;        value = v;    }    public K getKey() {        return key;    }    public void setKey(K key) {        this.key = key;    }    public V getValue() {        return value;    }    public void setValue(V value) {        this.value = value;    }}
在編譯期，是無法知道K和V具體是什么類型，只有在運行時才會真正根據(jù)類型來構(gòu)造和分配內(nèi)存。可以看一下現(xiàn)在Container類對于不同類型的支持情況：
public class Main {    public static void main(String[] args) {        Container<String, String> c1 = new Container<String, String>("name", "findingsea");        Container<String, Integer> c2 = new Container<String, Integer>("age", 24);        Container<Double, Double> c3 = new Container<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 : findingseaage : 241.1 : 2.2
泛型接口
在泛型接口中，生成器是一個很好的理解，看如下的生成器接口定義：
public interface Generator<T> {    public T next();}然后定義一個生成器類來實現(xiàn)這個接口：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)];    }}調(diào)用：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());    }}輸出：BananaBananaPearBanana
泛型方法
一個基本的原則是：無論何時，只要你能做到，你就應(yīng)該盡量使用泛型方法。也就是說，如果使用泛型方法可以取代將整個類泛化，那么應(yīng)該有限采用泛型方法。下面來看一個簡單的泛型方法的定義：
public class Main {    public static <T> void out(T t) {        System.out.println(t);    }    public static void main(String[] args) {        out("findingsea");        out(123);        out(11.11);        out(true);    }}
可以看到方法的參數(shù)徹底泛化了，這個過程涉及到編譯器的類型推導(dǎo)和自動打包，也就說原來需要我們自己對類型進行的判斷和處理，現(xiàn)在編譯器幫我們做了。這樣在定義方法的時候不必考慮以后到底需要處理哪些類型的參數(shù)，大大增加了編程的靈活性。
再看一個泛型方法和可變參數(shù)的例子：
public class Main {    public static <T> void out(T... args) {        for (T t : args) {            System.out.println(t);        }    }    public static void main(String[] args) {        out("findingsea", 123, 11.11, true);    }}
通配符與上下界
在使用泛型類的時候，既可以指定一個具體的類型，如List就聲明了具體的類型是String；也可以用通配符?來表示未知類型，如List
類型系統(tǒng)
在Java中，大家比較熟悉的是通過繼承機制而產(chǎn)生的類型體系結(jié)構(gòu)。比如String繼承自O(shè)bject。根據(jù)Liskov替換原則，子類是可以替換父類的。當(dāng)需要Object類的引用的時候，如果傳入一個String對象是沒有任何問題的。但是反過來的話，即用父類的引用替換子類引用的時候，就需要進行強制類型轉(zhuǎn)換。編譯器并不能保證運行時刻這種轉(zhuǎn)換一定是合法的。這種自動的子類替換父類的類型轉(zhuǎn)換機制，對于數(shù)組也是適用的。 String[]可以替換Object[]。但是泛型的引入，對于這個類型系統(tǒng)產(chǎn)生了一定的影響。正如前面提到的List是不能替換掉List的。
引入泛型之后的類型系統(tǒng)增加了兩個維度：
一個是類型參數(shù)自身的繼承體系結(jié)構(gòu)，另外一個是泛型類或接口自身的繼承體系結(jié)構(gòu)。第一個指的是對于 List和List這樣的情況，類型參數(shù)String是繼承自O(shè)bject的。而第二種指的是 List接口繼承自Collection接口。對于這個類型系統(tǒng)，有如下的一些規(guī)則：
相同類型參數(shù)的泛型類的關(guān)系取決于泛型類自身的繼承體系結(jié)構(gòu)。
即List是Collection 的子類型，List可以替換Collection。這種情況也適用于帶有上下界的類型聲明。
當(dāng)泛型類的類型聲明中使用了通配符的時候， 其子類型可以在兩個維度上分別展開。如對Collection
泛型的命名規(guī)范
為了更好地去理解泛型，我們也需要去理解java泛型的命名規(guī)范。為了與java關(guān)鍵字區(qū)別開來，java泛型參數(shù)只是使用一個大寫字母來定義。各種常用泛型參數(shù)的意義如下：
E — Element，常用在java Collection里，如：List,Iterator,SetK,V — Key，Value，代表Map的鍵值對N — Number，數(shù)字T — Type，類型，如String，Integer等等S,U,V etc. – 2nd, 3rd, 4th 類型，和T的用法一樣
學(xué)習(xí)Java的同學(xué)注意了！！！ 學(xué)習(xí)過程中遇到什么問題或者想獲取學(xué)習(xí)資源的話，歡迎加入Java學(xué)習(xí)交流群，群號碼：183993990  我們一起學(xué)Java！