怎樣理解Java的泛型及實(shí)現(xiàn)

本篇文章為大家展示了怎樣理解Java的泛型及實(shí)現(xiàn)，內(nèi)容簡(jiǎn)明扼要并且容易理解，絕對(duì)能使你眼前一亮，通過這篇文章的詳細(xì)介紹希望你能有所收獲。

泛型基礎(chǔ)

泛型是對(duì)Java語言類型系統(tǒng)的一種擴(kuò)展，有點(diǎn)類似于C++的模板，可以把類型參數(shù)看作是使用參數(shù)化類型時(shí)指定的類型的一個(gè)占位符。引入泛型，是對(duì)Java語言一個(gè)較大的功能增強(qiáng)，帶來了很多的好處：

1. 類型安全。類型錯(cuò)誤現(xiàn)在在編譯期間就被捕獲到了，而不是在運(yùn)行時(shí)當(dāng)作java.lang.ClassCastException展示出來，將類型檢查從運(yùn)行時(shí)挪到編譯時(shí)有助于開發(fā)者更容易找到錯(cuò)誤，并提高程序的可靠性

2. 消除了代碼中許多的強(qiáng)制類型轉(zhuǎn)換，增強(qiáng)了代碼的可讀性

3. 為較大的優(yōu)化帶來了可能

泛型是什么并不會(huì)對(duì)一個(gè)對(duì)象實(shí)例是什么類型的造成影響，所以，通過改變泛型的方式試圖定義不同的重載方法是不可以的。剩下的內(nèi)容我不會(huì)對(duì)泛型的使用做過多的講述，泛型的通配符等知識(shí)請(qǐng)自行查閱。

在進(jìn)入下面的論述之前我想先問幾個(gè)問題：

• 定義一個(gè)泛型類到底會(huì)生成幾個(gè)類，比如ArrayList<T>到底有幾個(gè)類

• 定義一個(gè)泛型方法最終會(huì)有幾個(gè)方法在class文件中

• 為什么泛型參數(shù)不能是基本類型呢

• ArrayList<Integer>是一個(gè)類嗎

• ArrayList<Integer>和List<Integer>和ArrayList<Number>和List<Number>是什么關(guān)系呢，這幾個(gè)類型的引用能相互賦值嗎

類型擦除

正確理解泛型概念的首要前提是理解類型擦除（type erasure）。  Java中的泛型基本上都是在編譯器這個(gè)層次來實(shí)現(xiàn)的。在生成的Java字節(jié)代碼中是不包含泛型中的類型信息的。使用泛型的時(shí)候加上的類型參數(shù)，會(huì)被編譯器在編譯的時(shí)候去掉。這個(gè)過程就稱為類型擦除。如在代碼中定義的List<Object>和List<String>等類型，在編譯之后都會(huì)變成List。JVM看到的只是List，而由泛型附加的類型信息對(duì)JVM來說是不可見的。Java編譯器會(huì)在編譯時(shí)盡可能的發(fā)現(xiàn)可能出錯(cuò)的地方，但是仍然無法避免在運(yùn)行時(shí)刻出現(xiàn)類型轉(zhuǎn)換異常的情況。類型擦除也是Java的泛型實(shí)現(xiàn)方式與C++模板機(jī)制實(shí)現(xiàn)方式之間的重要區(qū)別。

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

• 泛型類并沒有自己獨(dú)有的Class類對(duì)象。比如并不存在List<String>.class或是List<Integer>.class，而只有List.class。

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

• 泛型的類型參數(shù)不能用在Java異常處理的catch語句中。因?yàn)楫惓Ｌ幚硎怯蒍VM在運(yùn)行時(shí)刻來進(jìn)行的。由于類型信息被擦除，JVM是無法區(qū)分兩個(gè)異常類型MyException<String>和MyException<Integer>的。對(duì)于JVM來說，它們都是  MyException類型的。也就無法執(zhí)行與異常對(duì)應(yīng)的catch語句。

類型擦除的基本過程也比較簡(jiǎn)單，首先是找到用來替換類型參數(shù)的具體類。這個(gè)具體類一般是Object。如果指定了類型參數(shù)的上界的話，則使用這個(gè)上界。把代碼中的類型參數(shù)都替換成具體的類。同時(shí)去掉出現(xiàn)的類型聲明，即去掉<>的內(nèi)容。比如T  get()方法聲明就變成了Object get()；List<String>就變成了List。

泛型的實(shí)現(xiàn)原理

因?yàn)榉N種原因，Java不能實(shí)現(xiàn)真正的泛型，只能使用類型擦除來實(shí)現(xiàn)偽泛型，這樣雖然不會(huì)有類型膨脹（C++模板令人困擾的難題）的問題，但是也引起了許多新的問題。所以，Sun對(duì)這些問題作出了許多限制，避免我們犯各種錯(cuò)誤。

保證類型安全

首先***個(gè)是泛型所宣稱的類型安全，既然類型擦除了，如何保證我們只能使用泛型變量限定的類型呢？java編譯器是通過先檢查代碼中泛型的類型，然后再進(jìn)行類型擦除，在進(jìn)行編譯的。那類型檢查是針對(duì)誰的呢，讓我們先看一個(gè)例子。

ArrayList<String> arrayList1=new ArrayList(); // 正確，只能放入String ArrayList arrayList2=new ArrayList<String>(); // 可以放入任意Object

這樣是沒有錯(cuò)誤的，不過會(huì)有個(gè)編譯時(shí)警告。不過在***種情況，可以實(shí)現(xiàn)與  完全使用泛型參數(shù)一樣的效果，第二種則完全沒效果。因?yàn)?，本來類型檢查就是編譯時(shí)完成的。new  ArrayList()只是在內(nèi)存中開辟一個(gè)存儲(chǔ)空間，可以存儲(chǔ)任何的類型對(duì)象。而真正涉及類型檢查的是它的引用，因?yàn)槲覀兪鞘褂盟胊rrayList1  來調(diào)用它的方法，比如說調(diào)用add()方法。所以arrayList1引用能完成泛型類型的檢查。 而引用arrayList2沒有使用泛型，所以不行。

類型檢查就是針對(duì)引用的，誰是一個(gè)引用，用這個(gè)引用調(diào)用泛型方法，就會(huì)對(duì)這個(gè)引用調(diào)用的方法進(jìn)行類型檢測(cè)，而無關(guān)它真正引用的對(duì)象。

實(shí)現(xiàn)自動(dòng)類型轉(zhuǎn)換

因?yàn)轭愋筒脸膯栴}，所以所有的泛型類型變量***都會(huì)被替換為原始類型。這樣就引起了一個(gè)問題，既然都被替換為原始類型，那么為什么我們?cè)讷@取的時(shí)候，不需要進(jìn)行強(qiáng)制類型轉(zhuǎn)換呢？

public class Test {       public static void main(String[] args) {           ArrayList<Date> list=new ArrayList<Date>();           list.add(new Date());           Date myDate=list.get(0);     }       }

編譯器生成的class文件中會(huì)在你調(diào)用泛型方法完成之后返回調(diào)用點(diǎn)之前加上類型轉(zhuǎn)換的操作，比如上文的get函數(shù)，就是在get方法完成后，jump回原本的賦值操作的指令位置之前加入了強(qiáng)制轉(zhuǎn)換，轉(zhuǎn)換的類型由編譯器推導(dǎo)。

泛型中的繼承關(guān)系

先看一個(gè)例子：

class DateInter extends A<Date> {       @Override       public void setValue(Date value) {           super.setValue(value);       }       @Override       public Date getValue() {           return super.getValue();       }   }

先來分析setValue方法，父類的類型是Object，而子類的類型是Date，參數(shù)類型不一樣，這如果實(shí)在普通的繼承關(guān)系中，根本就不會(huì)是重寫，而是重載。

public void setValue(java.util.Date);  //我們重寫的setValue方法       Code:          0: aload_0          1: aload_1          2: invokespecial #16                // invoke A setValue :(Ljava/lang/Object;)V          5: return      public java.util.Date getValue();    //我們重寫的getValue方法       Code:          0: aload_0          1: invokespecial #23                 // A.getValue   :()Ljava/lang/Object;          4: checkcast     #26                       7: areturn      public java.lang.Object getValue();     //編譯時(shí)由編譯器生成的方法       Code:          0: aload_0          1: invokevirtual #28                 // Method getValue:() 去調(diào)用我們重寫的getValue方法   ;          4: areturn      public void setValue(java.lang.Object);   //編譯時(shí)由編譯器生成的方法       Code:          0: aload_0          1: aload_1          2: checkcast     #26                         5: invokevirtual #30                 // Method setValue;   去調(diào)用我們重寫的setValue方法   )V          8: return

并且，還有一點(diǎn)也許會(huì)有疑問，子類中的方法  Object   getValue()和Date getValue()是同  時(shí)存在的，可是如果是常規(guī)的兩個(gè)方法，他們的方法簽名是一樣的，也就是說虛擬機(jī)根本不能分別這兩個(gè)方法。如果是我們自己編寫Java代碼，這樣的代碼是無法通過編譯器的檢查的，但是虛擬機(jī)卻是允許這樣做的，因?yàn)樘摂M機(jī)通過參數(shù)類型和返回類型來確定一個(gè)方法，所以編譯器為了實(shí)現(xiàn)泛型的多態(tài)允許自己做這個(gè)看起來“不合法”的事情，然后交給虛擬器去區(qū)別。

我們?cè)倏匆粋€(gè)經(jīng)常出現(xiàn)的例子。

class A {     Object get(){         return new Object();     } }  class B extends A {     @Override     Integer get() {         return new Integer(1);     } }    public static void main(String[] args){     A a = new B();     B b = (B) a;     A c = new A();     a.get();     b.get();     c.get();   }

反編譯之后的結(jié)果

17: invokespecial #5                  // Method com/suemi/network/test/A."<init>":()V       20: astore_3       21: aload_1       22: invokevirtual #6                  // Method com/suemi/network/test/A.get:()Ljava/lang/Object;       25: pop       26: aload_2       27: invokevirtual #7                  // Method com/suemi/network/test/B.get:()Ljava/lang/Integer;       30: pop       31: aload_3       32: invokevirtual #6                  // Method com/suemi/network/test/A.get:()Ljava/lang/Object;

實(shí)際上當(dāng)我們使用父類引用調(diào)用子類的get時(shí)，先調(diào)用的是JVM生成的那個(gè)覆蓋方法，在橋接方法再調(diào)用自己寫的方法實(shí)現(xiàn)。

泛型參數(shù)的繼承關(guān)系

在Java中，大家比較熟悉的是通過繼承機(jī)制而產(chǎn)生的類型體系結(jié)構(gòu)。比如String繼承自O(shè)bject。根據(jù)Liskov替換原則，子類是可以替換父類的。當(dāng)需要Object類的引用的時(shí)候，如果傳入一個(gè)String對(duì)象是沒有任何問題的。但是反過來的話，即用父類的引用替換子類引用的時(shí)候，就需要進(jìn)行強(qiáng)制類型轉(zhuǎn)換。編譯器并不能保證運(yùn)行時(shí)刻這種轉(zhuǎn)換一定是合法的。這種自動(dòng)的子類替換父類的類型轉(zhuǎn)換機(jī)制，對(duì)于數(shù)組也是適用的。   String[]可以替換Object[]。但是泛型的引入，對(duì)于這個(gè)類型系統(tǒng)產(chǎn)生了一定的影響。正如前面提到的List<String>是不能替換掉List<Object>的。

引入泛型之后的類型系統(tǒng)增加了兩個(gè)維度：一個(gè)是類型參數(shù)自身的繼承體系結(jié)構(gòu)，另外一個(gè)是泛型類或接口自身的繼承體系結(jié)構(gòu)。***個(gè)指的是對(duì)于  List<String>和List<Object>這樣的情況，類型參數(shù)String是繼承自O(shè)bject的。而第二種指的是  List接口繼承自Collection接口。對(duì)于這個(gè)類型系統(tǒng)，有如下的一些規(guī)則：

相同類型參數(shù)的泛型類的關(guān)系取決于泛型類自身的繼承體系結(jié)構(gòu)。即List<String>可以賦給Collection<String>   類型的引用，List<String>可以替換Collection<String>。這種情況也適用于帶有上下界的類型聲明。 當(dāng)泛型類的類型聲明中使用了通配符的時(shí)候， 這種替換的判斷可以在兩個(gè)維度上分別展開。如對(duì)Collection<? extends  Number>來說，用來替換他的引用可以在Collection這個(gè)維度上展開，即List<? extends  Number>和Set<? extends  Number>等；也可以在Number這個(gè)層次上展開，即Collection<Double>和  Collection<Integer>等。如此循環(huán)下去，ArrayList<Long>和  HashSet<Double>等也都可以替換Collection<? extends Number>。

如果泛型類中包含多個(gè)類型參數(shù)，則對(duì)于每個(gè)類型參數(shù)分別應(yīng)用上面的規(guī)則。理解了上面的規(guī)則之后，就可以很容易的修正實(shí)例分析中給出的代碼了。只需要把List<Object>改成List<?>即可。List<String>可以替換List<?>的子類型，因此傳遞參數(shù)時(shí)不會(huì)發(fā)生錯(cuò)誤。

個(gè)人認(rèn)為這里對(duì)上面這種情形使用子類型這種說法來形容這種關(guān)系是不當(dāng)?shù)?，因?yàn)長(zhǎng)ist<String>等本質(zhì)上來說不能算作類型，只是對(duì)List類型加上了編譯器檢查約束，也就不存在子類型這種說法。只能用是否在賦值時(shí)能夠進(jìn)行類型轉(zhuǎn)換來說明。

泛型使用中的注意點(diǎn)

運(yùn)行時(shí)型別查詢

// 錯(cuò)誤，為類型擦除之后，ArrayList<String>只剩下原始類型，泛型信息String不存在了，無法進(jìn)行判斷 if( arrayList instanceof ArrayList<String>)   if( arrayList instanceof ArrayList<?>)    // 正確

異常中使用泛型的問題

• 不能拋出也不能捕獲泛型類的對(duì)象。事實(shí)上，泛型類擴(kuò)展Throwable都不合法。為什么不能擴(kuò)展Throwable，因?yàn)楫惓６际窃谶\(yùn)行時(shí)捕獲和拋出的，而在編譯的時(shí)候，泛型信息全都會(huì)被擦除掉。類型信息被擦除后，那么多個(gè)使用不同泛型參數(shù)地方的catch都變?yōu)樵碱愋蚈bject，那么也就是說，多個(gè)地方的catch變的一模一樣，這自然不被允許。

• 不能再catch子句中使用泛型變量。

public static <T extends Throwable> void doWork(Class<T> t){           try{               ...           }catch(T e){ //編譯錯(cuò)誤  T->Throwable，下面的永遠(yuǎn)不會(huì)被捕獲，所以不被允許             ...           }catch(IndexOutOfBounds e){           }                             }

不允許創(chuàng)建泛型類數(shù)組

Pair<String,Integer>[] table = new Pair<String,Integer>[10];// 編譯錯(cuò)誤 Pair[] table = new Pair[10];// 無編譯錯(cuò)誤

由于數(shù)組必須攜帶自己元素的類型信息，在類型擦除之后，Pair<String,Integer>數(shù)組就變成了Pair<Object,Object>數(shù)組，數(shù)組只能攜帶它的元素是Pair這樣的信息，但是并不能攜帶其泛型參數(shù)類型的信息，所以也就無法保證table[i]賦值的類型安全。編譯器只能禁用這種操作。

泛型類中的靜態(tài)方法和靜態(tài)變量

泛型類中的靜態(tài)方法和靜態(tài)變量不可以使用泛型類所聲明的泛型類型參數(shù)。

public class Test2<T> {         public static T one;   //編譯錯(cuò)誤         public static  T show(T one){ //編譯錯(cuò)誤             return null;         }     }

因?yàn)榉盒皖愔械姆盒蛥?shù)的實(shí)例化是在定義對(duì)象的時(shí)候指定的，而靜態(tài)變量和靜態(tài)方法不需要使用對(duì)象來調(diào)用。對(duì)象都沒有創(chuàng)建，如何確定這個(gè)泛型參數(shù)是何種類型，所以當(dāng)然是錯(cuò)誤的。

類型擦除后的沖突

class Pair<T>   {       public boolean equals(T value) {           return null;       }         }

方法重定義了，同時(shí)存在兩個(gè)equals(Object o)。

上述內(nèi)容就是怎樣理解Java的泛型及實(shí)現(xiàn)，你們學(xué)到知識(shí)或技能了嗎？如果還想學(xué)到更多技能或者豐富自己的知識(shí)儲(chǔ)備，歡迎關(guān)注億速云行業(yè)資訊頻道。