Java泛型

我們知道，使用變量之前要定義，定義一個變量時必須要指明它的數(shù)據(jù)類型，什么樣的數(shù)據(jù)類型賦給什么樣的值。

假如我們現(xiàn)在要定義一個類來表示坐標(biāo)，要求坐標(biāo)的數(shù)據(jù)類型可以是整數(shù)、小數(shù)和字符串，例如：
x = 10、y = 10
x = 12.88、y = 129.65
x = "東京180度"、y = "北緯210度"

針對不同的數(shù)據(jù)類型，除了借助方法重載，還可以借助自動裝箱和向上轉(zhuǎn)型。我們知道，基本數(shù)據(jù)類型可以自動裝箱，被轉(zhuǎn)換成對應(yīng)的包裝類；Object 是所有類的祖先類，任何一個類的實(shí)例都可以向上轉(zhuǎn)型為 Object 類型，例如：
int --> Integer --> Object
double -->Double --> Object
String --> Object

這樣，只需要定義一個方法，就可以接收所有類型的數(shù)據(jù)。請看下面的代碼：

public class Demo {
    public static void main(String[] args){
        Point p = new Point();
        p.setX(10);  // int -> Integer -> Object
        p.setY(20);
        int x = (Integer)p.getX();  // 必須向下轉(zhuǎn)型
        int y = (Integer)p.getY();
        System.out.println("This point is：" + x + ", " + y);
       
        p.setX(25.4);  // double -> Integer -> Object
        p.setY("東京180度");
        double m = (Double)p.getX();  // 必須向下轉(zhuǎn)型
        double n = (Double)p.getY();  // 運(yùn)行期間拋出異常
        System.out.println("This point is：" + m + ", " + n);
    }
}
class Point{
    Object x = 0;
    Object y = 0;
    public Object getX() {
        return x;
    }
    public void setX(Object x) {
        this.x = x;
    }
    public Object getY() {
        return y;
    }
    public void setY(Object y) {
        this.y = y;
    }
}

上面的代碼中，生成坐標(biāo)時不會有任何問題，但是取出坐標(biāo)時，要向下轉(zhuǎn)型，向下轉(zhuǎn)型存在著風(fēng)險(xiǎn)，而且編譯期間不容易發(fā)現(xiàn)，只有在運(yùn)行期間才會拋出異常，所以要盡量避免使用向下轉(zhuǎn)型。運(yùn)行上面的代碼，第12行會拋出 java.lang.ClassCastException 異常。那么，有沒有更好的辦法，既可以不使用重載（有重復(fù)代碼），又能把風(fēng)險(xiǎn)降到最低呢？有，可以使用泛型類(Java Class)，它可以接受任意類型的數(shù)據(jù)。所謂“泛型”，就是“寬泛的數(shù)據(jù)類型”，任意的數(shù)據(jù)類型。更改上面的代碼，使用泛型類：

public class Demo {
    public static void main(String[] args){
        // 實(shí)例化泛型類
        Point<Integer, Integer> p1 = new Point<Integer, Integer>();
        p1.setX(10);
        p1.setY(20);
        int x = p1.getX();
        int y = p1.getY();
        System.out.println("This point is：" + x + ", " + y);
       
        Point<Double, String> p2 = new Point<Double, String>();
        p2.setX(25.4);
        p2.setY("東京180度");
        double m = p2.getX();
        String n = p2.getY();
        System.out.println("This point is：" + m + ", " + n);
    }
}

// 定義泛型類
class Point<T1, T2>{
    T1 x;
    T2 y;
    public T1 getX() {
        return x;
    }
    public void setX(T1 x) {
        this.x = x;
    }
    public T2 getY() {
        return y;
    }
    public void setY(T2 y) {
        this.y = y;
    }
}

運(yùn)行結(jié)果：
This point is：10, 20
This point is：25.4, 東京180度

與普通類的定義相比，上面的代碼在類名后面多出了 <T1, T2>，T1, T2 是自定義的標(biāo)識符，也是參數(shù)，用來傳遞數(shù)據(jù)的類型，而不是數(shù)據(jù)的值，我們稱之為類型參數(shù)。在泛型中，不但數(shù)據(jù)的值可以通過參數(shù)傳遞，數(shù)據(jù)的類型也可以通過參數(shù)傳遞。T1, T2 只是數(shù)據(jù)類型的占位符，運(yùn)行時會被替換為真正的數(shù)據(jù)類型。

傳值參數(shù)（我們通常所說的參數(shù)）由小括號包圍，如 (int x, double y)，類型參數(shù)（泛型參數(shù)）由尖括號包圍，多個參數(shù)由逗號分隔，如 <T> 或 <T, E>。

類型參數(shù)需要在類名后面給出。一旦給出了類型參數(shù)，就可以在類中使用了。類型參數(shù)必須是一個合法的標(biāo)識符，習(xí)慣上使用單個大寫字母，通常情況下，K 表示鍵，V 表示值，E 表示異?；蝈e誤，T 表示一般意義上的數(shù)據(jù)類型。

泛型類在實(shí)例化時必須指出具體的類型，也就是向類型參數(shù)傳值，格式為：
className variable<dataType1, dataType2> = new className<dataType1, dataType2>();
也可以省略等號右邊的數(shù)據(jù)類型，但是會產(chǎn)生警告，即：
className variable<dataType1, dataType2> = new className();

因?yàn)樵谑褂梅盒皖悤r指明了數(shù)據(jù)類型，賦給其他類型的值會拋出異常，既不需要向下轉(zhuǎn)型，也沒有潛在的風(fēng)險(xiǎn)，比本文一開始介紹的自動裝箱和向上轉(zhuǎn)型要更加實(shí)用。

注意：
泛型是 Java 1.5 的新增特性，它以C++模板為參照，本質(zhì)是參數(shù)化類型(Parameterized Type)的應(yīng)用。
類型參數(shù)只能用來表示引用類型，不能用來表示基本類型，如 int、double、char 等。但是傳遞基本類型不會報(bào)錯，因?yàn)樗鼈儠詣友b箱成對應(yīng)的包裝類。

泛型方法

除了定義泛型類，還可以定義泛型方法，例如，定義一個打印坐標(biāo)的泛型方法：

public class Demo {
    public static void main(String[] args){
        // 實(shí)例化泛型類
        Point<Integer, Integer> p1 = new Point<Integer, Integer>();
        p1.setX(10);
        p1.setY(20);
        p1.printPoint(p1.getX(), p1.getY());
       
        Point<Double, String> p2 = new Point<Double, String>();
        p2.setX(25.4);
        p2.setY("東京180度");
        p2.printPoint(p2.getX(), p2.getY());
    }
}

// 定義泛型類
class Point<T1, T2>{
    T1 x;
    T2 y;
    public T1 getX() {
        return x;
    }
    public void setX(T1 x) {
        this.x = x;
    }
    public T2 getY() {
        return y;
    }
    public void setY(T2 y) {
        this.y = y;
    }
   
    // 定義泛型方法
    public <T1, T2> void printPoint(T1 x, T2 y){
        T1 m = x;
        T2 n = y;
        System.out.println("This point is：" + m + ", " + n);
    }
}

運(yùn)行結(jié)果：
This point is：10, 20
This point is：25.4, 東京180度

上面的代碼中定義了一個泛型方法 printPoint()，既有普通參數(shù)，也有類型參數(shù)，類型參數(shù)需要放在修飾符后面、返回值類型前面。一旦定義了類型參數(shù)，就可以在參數(shù)列表、方法體和返回值類型中使用了。

與使用泛型類不同，使用泛型方法時不必指明參數(shù)類型，編譯器會根據(jù)傳遞的參數(shù)自動查找出具體的類型。泛型方法除了定義不同，調(diào)用就像普通方法一樣。

注意：泛型方法與泛型類沒有必然的聯(lián)系，泛型方法有自己的類型參數(shù)，在普通類中也可以定義泛型方法。泛型方法 printPoint() 中的類型參數(shù) T1, T2 與泛型類 Point 中的 T1, T2 沒有必然的聯(lián)系，也可以使用其他的標(biāo)識符代替：

public static <V1, V2> void printPoint(V1 x, V2 y){
    V1 m = x;
    V2 n = y;
    System.out.println("This point is：" + m + ", " + n);
}

泛型接口

在Java中也可以定義泛型接口，這里不再贅述，僅僅給出示例代碼：

public class Demo {
    public static void main(String arsg[]) {
        Info<String> obj = new InfoImp<String>("www.weixueyuan.net");
        System.out.println("Length Of String: " + obj.getVar().length());
    }
}

//定義泛型接口
interface Info<T> {
    public T getVar();
}

//實(shí)現(xiàn)接口
class InfoImp<T> implements Info<T> {
    private T var;

    // 定義泛型構(gòu)造方法
    public InfoImp(T var) {
        this.setVar(var);
    }

    public void setVar(T var) {
        this.var = var;
    }

    public T getVar() {
        return this.var;
    }
}

類型擦除

如果在使用泛型時沒有指明數(shù)據(jù)類型，那么就會擦除泛型類型，請看下面的代碼：

public class Demo {
    public static void main(String[] args){
        Point p = new Point();  // 類型擦除
        p.setX(10);
        p.setY(20.8);
        int x = (Integer)p.getX();  // 向下轉(zhuǎn)型
        double y = (Double)p.getY();
        System.out.println("This point is：" + x + ", " + y);
    }
}

class Point<T1, T2>{
    T1 x;
    T2 y;
    public T1 getX() {
        return x;
    }
    public void setX(T1 x) {
        this.x = x;
    }
    public T2 getY() {
        return y;
    }
    public void setY(T2 y) {
        this.y = y;
    }
}

運(yùn)行結(jié)果：
This point is：10, 20.8

因?yàn)樵谑褂梅盒蜁r沒有指明數(shù)據(jù)類型，為了不出現(xiàn)錯誤，編譯器會將所有數(shù)據(jù)向上轉(zhuǎn)型為 Object，所以在取出坐標(biāo)使用時要向下轉(zhuǎn)型，這與本文一開始不使用泛型沒什么兩樣。

限制泛型的可用類型

在上面的代碼中，類型參數(shù)可以接受任意的數(shù)據(jù)類型，只要它是被定義過的。但是，很多時候我們只需要一部分?jǐn)?shù)據(jù)類型就夠了，用戶傳遞其他數(shù)據(jù)類型可能會引起錯誤。例如，編寫一個泛型函數(shù)用于返回不同類型數(shù)組（Integer 數(shù)組、Double 數(shù)組、Character 數(shù)組等）中的最大值：

public <T> T getMax(T array[]){
    T max = null;
    for(T element : array){
        max = element.doubleValue() > max.doubleValue() ? element : max;
    }
    return max;
}

上面的代碼會報(bào)錯，doubleValue() 是 Number 類的方法，不是所有的類都有該方法，所以我們要限制類型參數(shù) T，讓它只能接受 Number 及其子類（Integer、Double、Character 等）。

通過 extends 關(guān)鍵字可以限制泛型的類型，改進(jìn)上面的代碼：

public <T extends Number> T getMax(T array[]){
    T max = null;
    for(T element : array){
        max = element.doubleValue() > max.doubleValue() ? element : max;
    }
    return max;
}

<T extends Number> 表示 T 只接受 Number 及其子類，傳入其他類型的數(shù)據(jù)會報(bào)錯。這里的限定使用關(guān)鍵字 extends，后面可以是類也可以是接口。但這里的 extends 已經(jīng)不是繼承的含義了，應(yīng)該理解為 T 是繼承自 Number 類的類型，或者 T 是實(shí)現(xiàn)了 XX 接口的類型。

類型參數(shù)的范圍

在泛型中，如果不對類型參數(shù)加以限制，它就可以接受任意的數(shù)據(jù)類型，只要它是被定義過的。但是，很多時候我們只需要一部分?jǐn)?shù)據(jù)類型就夠了，用戶傳遞其他數(shù)據(jù)類型可能會引起錯誤。例如，編寫一個泛型函數(shù)用于返回不同類型數(shù)組（Integer 數(shù)組、Double 數(shù)組等）中的最大值：

public <T> T getMax(T array[]){
    T max = null;
    for(T element : array){
        max = element.doubleValue() > max.doubleValue() ? element : max;
    }
    return max;
}

上面的代碼會報(bào)錯，doubleValue() 是 Number 類及其子類的方法，不是所有的類都有該方法，所以我們要限制類型參數(shù) T，讓它只能接受 Number 及其子類（Integer、Double、Character 等）。

通過 extends 關(guān)鍵字可以限制泛型的類型的上限，改進(jìn)上面的代碼：

public <T extends Number> T getMax(T array[]){
    T max = null;
    for(T element : array){
        max = element.doubleValue() > max.doubleValue() ? element : max;
    }
    return max;
}

<T extends Number> 表示 T 只接受 Number 及其子類，傳入其他類型的數(shù)據(jù)會報(bào)錯。這里的限定使用關(guān)鍵字 extends，后面可以是類也可以是接口。如果是類，只能有一個；但是接口可以有多個，并以“&”分隔，例如 <T extends Interface1 & Interface2>。

這里的 extends 關(guān)鍵字已不再是繼承的含義了，應(yīng)該理解為 T 是繼承自 Number 類的類型，或者 T 是實(shí)現(xiàn)了 XX 接口的類型。

通配符(?)

要定義一個泛型類來表示坐標(biāo)，坐標(biāo)可以是整數(shù)、小數(shù)或字符串，請看下面的代碼：

class Point<T1, T2>{
    T1 x;
    T2 y;
    public T1 getX() {
        return x;
    }
    public void setX(T1 x) {
        this.x = x;
    }
    public T2 getY() {
        return y;
    }
    public void setY(T2 y) {
        this.y = y;
    }
}

現(xiàn)在要求在類的外部定義一個 printPoint() 方法用于輸出坐標(biāo)，怎么辦呢？

可以這樣來定義方法：

public void printPoint(Point p){
    System.out.println("This point is: " + p.getX() + ", " + p.getY());
}

我們知道，如果在使用泛型時沒有指名具體的數(shù)據(jù)類型，就會擦除泛型類型，并向上轉(zhuǎn)型為 Object，這與不使用泛型沒什么兩樣。上面的代碼沒有指明數(shù)據(jù)類型，相當(dāng)于：

public void printPoint(Point<Object, Object> p){
    System.out.println("This point is: " + p.getX() + ", " + p.getY());
}

為了避免類型擦除，可以使用通配符(?)：

public void printPoint(Point<?, ?> p){
    System.out.println("This point is: " + p.getX() + ", " + p.getY());
}

通配符(?)可以表示任意的數(shù)據(jù)類型。將代碼補(bǔ)充完整：

public class Demo {
    public static void main(String[] args){
        Point<Integer, Integer> p1 = new Point<Integer, Integer>();
        p1.setX(10);
        p1.setY(20);
        printPoint(p1);
      
        Point<String, String> p2 = new Point<String, String>();
        p2.setX("東京180度");
        p2.setY("北緯210度");
        printPoint(p2);
    }
   
    public static void printPoint(Point<?, ?> p){  // 使用通配符
        System.out.println("This point is: " + p.getX() + ", " + p.getY());
    }
}

class Point<T1, T2>{
    T1 x;
    T2 y;
    public T1 getX() {
        return x;
    }
    public void setX(T1 x) {
        this.x = x;
    }
    public T2 getY() {
        return y;
    }
    public void setY(T2 y) {
        this.y = y;
    }
}

運(yùn)行結(jié)果：
This point is: 10, 20
This point is: 東京180度, 北緯210度

但是，數(shù)字坐標(biāo)與字符串坐標(biāo)又有區(qū)別：數(shù)字可以表示x軸或y軸的坐標(biāo)，字符串可以表示地球經(jīng)緯度。現(xiàn)在又要求定義兩個方法分別處理不同的坐標(biāo)，一個方法只能接受數(shù)字類型的坐標(biāo)，另一個方法只能接受字符串類型的坐標(biāo)，怎么辦呢？

這個問題的關(guān)鍵是要限制類型參數(shù)的范圍，請先看下面的代碼：

public class Demo {
    public static void main(String[] args){
        Point<Integer, Integer> p1 = new Point<Integer, Integer>();
        p1.setX(10);
        p1.setY(20);
        printNumPoint(p1);
      
        Point<String, String> p2 = new Point<String, String>();
        p2.setX("東京180度");
        p2.setY("北緯210度");
        printStrPoint(p2);
    }
   
    // 借助通配符限制泛型的范圍
    public static void printNumPoint(Point<? extends Number, ? extends Number> p){
        System.out.println("x: " + p.getX() + ", y: " + p.getY());
    }
   
    public static void printStrPoint(Point<? extends String, ? extends String> p){
        System.out.println("GPS: " + p.getX() + "，" + p.getY());
    }
}

class Point<T1, T2>{
    T1 x;
    T2 y;
    public T1 getX() {
        return x;
    }
    public void setX(T1 x) {
        this.x = x;
    }
    public T2 getY() {
        return y;
    }
    public void setY(T2 y) {
        this.y = y;
    }
}

運(yùn)行結(jié)果：
x: 10, y: 20
GPS: 東京180度，北緯210度

? extends Number 表示泛型的類型參數(shù)只能是 Number 及其子類，? extends String 也一樣，這與定義泛型類或泛型方法時限制類型參數(shù)的范圍類似。

不過，使用通配符(?)不但可以限制類型的上限，還可以限制下限。限制下限使用 super 關(guān)鍵字，例如 <? super Number> 表示只能接受 Number 及其父類

淺談Java泛型之<? extends T>和<? super T>的區(qū)別

關(guān)于Java泛型,這里我不想總結(jié)它是什么,這個百度一下一大堆解釋,各種java的書籍中也有明確的定義,只要稍微看一下就能很快清楚.從泛型的英文名字Generic type也能看出,Generic普通、一般、通用的,是一個概括性的詞,那么泛型從名字上也就好理解了,它是一種通用類型,是java中各種類型的概括.
?是java泛型中的通配符,它代表java中的某一個類,那么<? extends T>就代表類型T的某個子類,<? super T>就代表類型T的某個父類.
這里我們先定義一組有繼承關(guān)系的類:
//子類-->父類小紅蘋果--紅蘋果--蘋果--水果--好吃的--吃的

這些類都是左側(cè)的類為與它相連接的右側(cè)的類的子類.
那么<? extends 蘋果> 代表的是左側(cè)藍(lán)字和綠字的類中的某個類,而<? super 蘋果>代表的就是綠字和紅字的類中的某個類.
這里要注意的是<? extends T>或是<? super T>代表的是范圍內(nèi)的某個特定的類,而不是范圍內(nèi)的所有類.
//所以只要在范圍內(nèi),我們可以如下這樣的隨意賦值
List<? extends 蘋果> list1 = new ArrayList<蘋果>();
List<? extends 蘋果> list2= new ArrayList<紅蘋果>();
List<? extends 蘋果> list3 = new ArrayList<小紅蘋果>();

但是對于List<? extends 蘋果> list來說,代表的是一個范圍內(nèi)的某個類,但是卻不確定是哪個類,所以如果我們向這個list中添加元素的時候:
List<? extends 蘋果> list = new ArrayList<蘋果>();
list.add(蘋果); //編譯錯誤
list.add(紅蘋果); //編譯錯誤
list.add(小紅蘋果); //編譯錯誤

因?yàn)榫幾g器并不知道list到底是哪個類(只有在運(yùn)行的時候才能確定指代的哪個類),如果list是紅蘋果,那么list.add(蘋果)就將一個父類賦值給子類了,是錯誤的.顯然如果向這個list中添加類,都不能保證是正確的.可能會說小紅蘋果沒有子類,添加小紅蘋果不會錯,但是這只是我定義的一個繼承圖中是這樣,我們完全可以繼續(xù)定義個小小紅蘋果來繼承小紅蘋果,這個繼承是沒有下限的.這個反推出一個結(jié)論<? extends T>是一個有上限T的類型.那么我們馬上就發(fā)現(xiàn)<? super T>實(shí)際上是有下限T的類型.
因?yàn)閷τ?lt;? extends T>有上限T,故我們?nèi)绻鹟ist.get(0)一定返回的是T或是T的子類,這個是確定的,得出:
List<? extends 蘋果> list1 = new ArrayList<蘋果>();
蘋果 a = list1.get(0); //這個是一定成立的,編譯也不會有問題
List<? extends 蘋果> list2 = new ArrayList<紅蘋果>();
蘋果 a = list2.get(0);
List<? extends 蘋果> list3 = new ArrayList<小紅蘋果>();
蘋果 a = list3.get(0);

然后我們來看<? super T>,因?yàn)樗邢孪?故我們可以馬上得出,如果向其中添加T類型的對象是沒問題的.因?yàn)?lt;? super T>是T的某個父類,將子類T賦值給父類沒任何問題:
List<? super 蘋果> list = new ArrayList<蘋果>();
list.add(蘋果); //無任何問題
List<? super 蘋果> list = new ArrayList<水果>();
list.add(蘋果); //無任何問題

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

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

  • 開發(fā)人員在使用泛型的時候，很容易根據(jù)自己的直覺而犯一些錯誤。比如一個方法如果接收List作為形式參數(shù)，那么如果嘗試...
    時待吾閱讀 1,128評論 0贊 3
  • 為什么需要泛型？ 通過泛型可以定義類型安全的數(shù)據(jù)結(jié)構(gòu)，而無須使用實(shí)際的數(shù)據(jù)類型（可擴(kuò)展）。這能夠顯著提高性能并得到...
    一只好奇的茂閱讀 1,353評論 2贊 39
  • 一、泛型簡介1.引入泛型的目的 了解引入泛型的動機(jī)，就先從語法糖開始了解。 語法糖 語法糖（Syntactic S...
    Android進(jìn)階與總結(jié)閱讀 1,079評論 0贊 9
  • 泛型的好處 使用泛型的好處我覺得有兩點(diǎn)：1：類型安全 2：減少類型強(qiáng)轉(zhuǎn) 下面通過一個例子說明: 假設(shè)有一個Tes...
    德彪閱讀 1,220評論 0贊 0
  • 初伏 第5天總結(jié) 驚嘆 我不知道如何形容我的驚嘆程度，當(dāng)我看到大家只用弗洛茲一個圖樣創(chuàng)作的作品時，完全超出想象！所...
    木之慧閱讀 4,479評論 5贊 39

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