Java的泛型解析

一、為什么要使用泛型

1.類型參數(shù)的好處

  • 類型安全：泛型的主要目標(biāo)是提高 Java 程序的類型安全。通過知道使用泛型定義的變量的類型限制，編譯器可以在一個高得多的程度上驗證類型假設(shè)。沒有泛型，這些假設(shè)就只存在于程序員的頭腦中（或者如果幸運的話，還存在于代碼注釋中）。

  • 消除強(qiáng)制類型轉(zhuǎn)換：泛型的一個附帶好處是，消除源代碼中的許多強(qiáng)制類型轉(zhuǎn)換。這使得代碼更加可讀，并且減少了出錯機(jī)會。

Java語言引入泛型的好處是安全簡單。泛型的好處是在編譯的時候檢查類型安全，并且所有的強(qiáng)制轉(zhuǎn)換都是自動和隱式的，提高代碼的重用率。

二、定義簡單的泛型類

泛型類的定義比較簡單，如下便可以定義一個泛型類，在實例化泛型類的時候必須指明泛型的具體類型。

public class Pair<T>{
    private T first;
    private T second;
    
    public Pair(){
        first = null;second = null;
    }
    
    public T getFirst(){
        return first;
    }
    
    public T getSecond(){
        return second;
    }
    
    public void setFirst(T newValue){
        first = newValue;
    }
    public void setSecond(T newValue){
        second = newValue;
    }
}

泛型在使用中還有一些規(guī)則和限制：

  • 泛型的類型參數(shù)只能是類類型（包括自定義類），不能是簡單類型。
  • 同一種泛型可以對應(yīng)多個版本（因為參數(shù)類型是不確定的），不同版本的泛型類實例是不兼容的。
  • 泛型的類型參數(shù)可以有多個。
  • 泛型的參數(shù)類型可以使用extends語句，例如<T extends superclass>。習(xí)慣上成為“有界類型”。
  • 泛型的參數(shù)類型還可以是通配符類型。例如Class<?> classType = Class.forName(Java.lang.String);

泛型類可以定義多個類型變量，例如

public class Pari<T,U>{
    ...
}

三、泛型方法

Java中的泛型方法相對復(fù)雜一點，在調(diào)用的時候需要指明泛型類型

定義泛型的語法：

image

調(diào)用泛型的語法：

image

定義泛型方法時，必須在返回值前邊加一個<T>，來聲明這是一個泛型方法，持有一個泛型T，然后才可以用泛型T作為方法的返回值。注意：類型變量放在修飾符的后面，返回類型的前面。

既然是泛型方法，就代表著我們不知道具體的類型是什么，也不知道構(gòu)造方法如何，因此沒有辦法去new一個對象，但可以利用變量c的newInstance方法去創(chuàng)建對象，也就是利用反射創(chuàng)建對象。

泛型方法要求的參數(shù)是Class<T>類型，而Class.forName()方法的返回值也是Class<T>，因此可以用Class.forName()作為參數(shù)。其中，forName()方法中的參數(shù)是何種類型，返回的Class<T>就是何種類型。在本例中，forName()方法中傳入的是User類的完整路徑，因此返回的是Class<User>類型的對象，因此調(diào)用泛型方法時，變量c的類型就是Class<User>，因此泛型方法中的泛型T就被指明為User，因此變量obj的類型為User。

四、類型變量的限定

我們都知道在方法前指定了<T>，那么就是說這個泛型類型和類定義時的泛型類型無關(guān)，所以可以在普通類中定義泛型方法，泛型可以限定類型變量必須實現(xiàn)某幾種接口或者繼承某個雷，多個限定類型通過&分隔，如：

public static <T extends Comparable> T min(T[] a)...

對泛型進(jìn)行限制，使其只有集成或?qū)崿F(xiàn)Comparable的類才能使用該方法

(1) ? extends X:表示類型的上界

特點：

  • 限定 ? 為 X 的子類型，但不知道是哪個子類型
  • 可以安全的訪問數(shù)據(jù)，訪問X及其子類型
<T extends BoundingType>

T表示綁定類型的子類型，T和綁定類型可以是類或者接口。

一個變量或者通配符可以綁定多個限定，用“&”分開

T extends Comparable & Serializable

若T的限定類型是類，則有且最多只有一個，且放于接口前面

五、泛型代碼和虛擬機(jī)

Java虛擬機(jī)是不存在泛型類型對象的，所有的對象都屬于普通類，甚至在泛型實現(xiàn)的早起版本中，可以將使用泛型的程序編譯為在1.0虛擬機(jī)上能夠運行的class文件，這個向后兼容性后期被拋棄了，所以后來如果用Sun公司的編譯器編譯的泛型代碼，是不能運行在Java5.0之前的虛擬機(jī)的，這樣就導(dǎo)致了一些實際生產(chǎn)的問題，如一些遺留代碼如何跟新的系統(tǒng)進(jìn)行銜接，要弄明白這個問題，需要先了解一下虛擬機(jī)是怎么執(zhí)行泛型代碼的。

1.類型擦除

類型擦除指的是通過類型參數(shù)合并，將泛型類型實例關(guān)聯(lián)到同一份字節(jié)碼上。編譯器只為泛型類型生成一份字節(jié)碼，并將其實例關(guān)聯(lián)到這份字節(jié)碼上。類型擦除的關(guān)鍵在于從泛型類型中清除類型參數(shù)的相關(guān)信息，并且再必要的時候添加類型檢查和類型轉(zhuǎn)換的方法。

虛擬機(jī)的一種機(jī)制：擦除類型參數(shù)，并將其替換成限定類型，沒有限定類型用Object代替

public class Period<T extends Comparable<T> & Serializable> {  
      private T begin;  
      private T end;  
  
      public Period(T one, T two) {  
               if (one.compareTo(two) > 0) {begin = two;end = one;  
              } else {begin = one;end = two;}  
     }  
}  


//擦除后
public class Period implements Serializable{  
      private Comparable begin;  
      private Comparable end;  
  
      public Period(Comparable one, Comparable two) {  
               if (one.compareTo(two) > 0) {begin = two; end = one;  
              } else {begin = one; end = two;}  
     }  
}

Java泛型的處理幾乎都在編譯器中進(jìn)行，編譯器生成的字節(jié)碼是不包涵泛型信息的，泛型類型信息將在編譯處理是被擦除，這個過程即類型擦除。通常情況下，Java是通過以下方式處理泛型：Java編譯器通過Code sharing方式為每個泛型類型創(chuàng)建唯一的字節(jié)碼表示，并且將該泛型類型的實例都映射到這個唯一的字節(jié)碼表示上。將多種泛型類形實例映射到唯一的字節(jié)碼表示是通過類型擦除（type erasue）實現(xiàn)的。

Code sharing：對每個泛型類只生成唯一的一份目標(biāo)代碼；該泛型類的所有實例都映射到這份目標(biāo)代碼上，在需要的時候執(zhí)行類型檢查和類型轉(zhuǎn)換。

注意：
當(dāng)存在情況：class Interval<T extends Serializable & Comparable> ，原始類型用Serializable替換T，在有必要的時候向Comparable強(qiáng)制類型轉(zhuǎn)換，為了提高效率，應(yīng)該將沒有方法的接口放在列表的后面。

類型擦除帶來的靈異問題：

  • 無法用同一泛型類型的實例區(qū)分方法簽名
    public class Erasure{  
  
            public void test(List<String> ls){  
                System.out.println("Sting");  
            }  
            public void test(List<Integer> li){  
                System.out.println("Integer");  
            }  
    }
image
image
  • 不能同時catch同一泛型異常類的多個實例
  • 泛型類的靜態(tài)變量是可以共享的
import java.util.*;  
  
public class StaticTest{  
    public static void main(String[] args){  
        GT<Integer> gti = new GT<Integer>();  
        gti.var=1;  
        GT<String> gts = new GT<String>();  
        gts.var=2;  
        System.out.println(gti.var);  
    }  
}  
class GT<T>{  
    public static int var=0;  
    public void nothing(T x){}  
}

//輸出2

2.翻譯泛型表達(dá)式

Couple<Employee> couple = ...;  
Employee wife = couple.getWife();

擦除后，getWife()返回的是Object類型，然后虛擬機(jī)會插入強(qiáng)制類型轉(zhuǎn)換，將Object轉(zhuǎn)換為Employee，所以虛擬機(jī)實際上執(zhí)行了兩天指令：

  • 1.調(diào)用Couple.getWife()方法。
  • 2.將Object轉(zhuǎn)換成Employee類型。

3.翻譯泛型方法

public static <T extends Comparable<T>> max(T[] arrays) {... }  
擦除后成了:  
public static Comoparable max(Comparable[] arrays) {... }  

public class Period <T extends Comparable<T> & Serializable> {  
      private T begin;  
      private T end;  
  
      public Period(T one, T two) {  
               if (one.compareTo(two) > 0) {begin = two;end = one;  
              } else {begin = one;end = two;}  
     }  
     public void setBegin(T begin) {this. begin = begin;}  
     public void setEnd(T end) {this. end = end;}  
     public T getBegin() {return begin;}  
     public T getEnd() {return end;}  
}  
public class DateInterval extends Period<Date> {  
  
      public DateInterval(Date one, Date two) {  
               super(one, two);  
     }  
      public void setBegin(Date begin) {  
               super.setBegin(begin);  
     }  
}

DateInterval類型擦除后，Period中的方法變成：

  • public void setBegin(Object begin) {...}

而DateInterval中的方法還是：

  • public void setBegin(Date begin) {...}

所以DateInterval從Period中繼承了 public void setBegin(Object begin) {...}而自身又存在public void setBegin(Date begin) {...}方法，用戶使用時問題發(fā)生了：

Period<Date> period  = new DateInterval(...);  
period.setBegin(new Date());

這里因為period引用指向了DateInterval實例，根據(jù)多態(tài)性，setBegin應(yīng)該調(diào)用DateInterval對象的setBegin方法，可是這個擦除讓Period中的 public void setBegin(Object begin) {...}被調(diào)用，導(dǎo)致了擦除與多態(tài)發(fā)生了沖突，怎么辦呢？虛擬機(jī)此時會在DateInterval類中生成一個橋方法(bridge method)，調(diào)用過程發(fā)生了細(xì)微的變化：

public void setBegin(Object begin) {  
     setBegin((Date)begin);  
 }

有了這個合成的橋方法以后，code07中對setBegin的調(diào)用步驟如下：

1.調(diào)用DateInterval.setBegin(Object)方法。
2.DateInterval.setBegin(Object)方法調(diào)用DateInterval.setBegin(Date)方法。

發(fā)現(xiàn)了嗎，當(dāng)我們在DateInterval中增加了getBegin方法之后會是什么樣子的呢？是不是Peroid中有一個Object getBegin()的方法，而DateInterval中有一個Date getBegin()方法呢，這兩個方法在Java中是不能同時存在的，可是Java5以后增加了一個協(xié)變類型，使得這里是被允許的，看看DateInterval中g(shù)etBegin方法就知道了：

@Override  
public Date getBegin(){ return super.getBegin(); }

這里用了@Override，說明是覆蓋了父類的Object getBegin()方法，而返回值可以指定為父類中的返回值類型的子類，這就是協(xié)變類型，這是Java5以后才可以允許的，允許子類覆蓋了方法后指定一個更嚴(yán)格的類型(子類型)。

總結(jié)：

  • 1.記住一點，虛擬機(jī)中沒有泛型，只有普通的類。
  • 2.所有泛型的類型參數(shù)都用它們限定的類型代替，沒有限定則用Object。
  • 3.為了保持類型安全性，虛擬機(jī)在有必要時插入強(qiáng)制類型轉(zhuǎn)換。
  • 4.橋方法的合成用來保持多態(tài)性。
  • 5.協(xié)變類型允許子類覆蓋方法后返回一個更嚴(yán)格的類型。

六、約束和局限性

1.不能使用基本類型實例化泛型

不能使用基本類型作為類型參數(shù)，因為擦除之后，可能會是Object類型，Object類型是無法存儲基本類型的

2.運行時類型檢查只適用于原始類型

  • 使用getClass會返回一個原始類型，比如Object；
  • 使用instanceof和強(qiáng)制轉(zhuǎn)換都會出現(xiàn)錯誤和警告。
if(a instanceof Pari<String>) //Error
Pair<String> p = (Pair<String>) a;//Error

Pair<Employee> employee = ...
Pair<String> stringPari = ...
if(employee.getClasss()==stringPari.getClass())//返回true

3.不能創(chuàng)建參數(shù)化類型數(shù)組

不能實例化參數(shù)化類型數(shù)組，可以聲明變量：Pari<String>[] table,只是不能new，這樣做是為了保證數(shù)組的安全，因為在類型擦除的時候會變?yōu)镺bject，防止數(shù)組可以add任何元素進(jìn)去。

Pair<String>[] table = new Pair<String>[10];//Error

4.不能實例化類型變量

類型擦除會將T修改為Object，而new Object()是不被允許的，可以通過反射來實例化一個泛型對象。

public Pair(){
    first = new T();
    second = new T();
}

5.不能構(gòu)造泛型數(shù)組

因為類型擦除，不允許實例化一個泛型數(shù)組，防止add的時候出現(xiàn)ArrayStoreException。

public static <T extends Comparable >T[] minmax(T[] a){ //Error
    T[] mm = new T[2];
    ...
}

如果想實例化泛型數(shù)組，可以通過以下方法來解決：

  • 通過反射來解決
public static <T extends Comparable> T[] minmax(T ... t){
    T[] mm = (T[]) Array.newInstance(a.getClass().getComponentType(),2);
}

七、通配符類型

通配符類型中，允許參數(shù)類型變化，前面的 ? extends X,可以讓編譯器知道只需要某個X的子類型，拒絕傳遞其他特定類型。

1.通配符超類型限定

表示類型的下界，格式是：？ super X。

特點：

1、限定為X和X的超類型，直至Object類，因為不知道具體是哪個超類型，因此方法返回的類型只能賦給Object。

2、因為可以向上轉(zhuǎn)型，所以作為方法的參數(shù)時，可以傳遞X以及X的超類型。

3、作為方法的參數(shù)時，可以傳遞null。

作用：主要用來安全地寫入數(shù)據(jù)，可以寫入X及其超類型。

/** 
 * ICE 
 * 2016/10/17 0017 14:12 
 */  
public class Demo {  
    public static void main(String[] args) {  
        A a = new A();  
        B b = new B();  
        C c = new C();  
  
        D<? super A> d = new D<>();  
        Object o = d.get();  
  
        d.set(a);  
        d.set(b);  
        d.set(c);  
        d.set(null);  
    }  
}  
  
class A {  
    @Override  
    public String toString() {  
        return "A{}";  
    }  
}  
  
class B extends A {  
    @Override  
    public String toString() {  
        return "B{}";  
    }  
}  
  
class C extends A {  
    @Override  
    public String toString() {  
        return "C{}";  
    }  
}  
  
class D<T> {  
    public void set(T t) {  
    }  
  
    public T get() {  
        return null;  
    }  
}

2.無限制

無限定不等于可以傳任何值，相反，作為方法的參數(shù)時，只能傳遞null，作為方法的返回時，只能賦給Object。

public class Demo {  
    public static void main(String[] args) {  
        D<?> d = new D<>();  
        Object o = d.get();  
        d.set(null);  
    }  
}  
  
class A {  
    @Override  
    public String toString() {  
        return "A{}";  
    }  
}  
  
class B extends A {  
    @Override  
    public String toString() {  
        return "B{}";  
    }  
}  
  
class C extends A {  
    @Override  
    public String toString() {  
        return "C{}";  
    }  
}  
  
class D<T> {  
    public void set(T t) {  
    }  
  
    public T get() {  
        return null;  
    }  
}

有什么作用呢？對于一些簡單的操作比如不需要實際類型的方法，就顯得比泛型方法簡潔，可以這樣說：如果是“讀”操作 則需要限定 上邊界，如果是寫操作則需要限定下邊界；而無限定通配符表示只讀，不能進(jìn)行增加、修改。

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • 引言：泛型一直是困擾自己的一個難題，但是泛型有時一個面試時老生常談的問題；今天作者就通過查閱相關(guān)資料簡單談?wù)勛约簩?..
    cp_insist閱讀 1,931評論 0贊 4
  • 泛型是Java 1.5引入的新特性。泛型的本質(zhì)是參數(shù)化類型，這種參數(shù)類型可以用在類、變量、接口和方法的創(chuàng)建中，分別...
    何時不晚閱讀 3,115評論 0贊 2
  • object 變量可指向任何類的實例，這讓你能夠創(chuàng)建可對任何數(shù)據(jù)類型進(jìn)程處理的類。然而，這種方法存在幾個嚴(yán)重的問題...
    CarlDonitz閱讀 1,018評論 0贊 5
  • Why ——引入泛型機(jī)制的原因 假如我們想要實現(xiàn)一個String數(shù)組，并且要求它可以動態(tài)改變大小，這時我們都會想到...
    absfree閱讀 5,270評論 1贊 6
  • 泛型的好處 使用泛型的好處我覺得有兩點：1：類型安全 2：減少類型強(qiáng)轉(zhuǎn) 下面通過一個例子說明: 假設(shè)有一個Tes...
    德彪閱讀 1,214評論 0贊 0

友情鏈接更多精彩內(nèi)容