java

【Core Java系列2】泣血整理!Java泛型最全歸納,你知道的和不知道的都能找到

前言

Java當中的泛型是JDK1.5版本中引入的一項技術,使用泛型可以使得我們的程式碼更加安全,而且具備更好的可讀性。泛型大家都有所瞭解,可能覺得非常簡單,然而,泛型也有許許多多需要注意的細節,本文的主要目的就是將泛型的使用細節及注意事項一一歸納。

沒有泛型的程式

下面是一段沒有使用泛型的程式碼示例:

package com.zwx.coreJava.genericity;

import .util.ArrayList;
import java.util.List;

public class MyItem {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(1);
        list.add("中國");
        for (int i=0;i<list.size();i++){
             int a = (int)list.get(i);
             System.out.println(a);
        }
    }
}

顯然,上面這段程式碼可以正常編譯,但是執行的時候就會報錯,這就是沒有泛型約束造成的後果,我們可以向list中新增任意資料型別,但是取值的時候就很容易出現型別轉換異常,所以為了使Java程式更加安全,泛型技術就應運而生了。

帶有泛型的程式

現在我麼透過泛型將上面的程式進行改造一下:

List<Integer> list = new ArrayList<>();

因為改造之後的程式加入了泛型的約束,那麼就限制了我們只能向list中新增Integer型別的資料,而如果新增其他型別,比如String型別(如下所示),那麼就會在編譯階段無法透過:

list.add("中國"); //編譯不透過

上面沒有新增泛型時,我們每次取出集合中的元素都需要進行型別強轉,而加了泛型,在取值的時候我們也不需要再手動去型別強轉,直接取出來(用約束的型別接收)就可以了,無需強轉,程式碼又美觀又安全:

 int a = list.get(i);//無需強轉
 System.out.println(a);

PS:注意:8種基本資料型別不能作為泛型,泛型必須要使用其對應的包裝類

泛型的定義

上面透過一個簡單的對比示例展示瞭如何用泛型以及使用泛型的好處,而上面使用的泛型實際上是一種指定了具體型別的泛型。

直接指定具體泛型的方式是最簡單的,我們大部分場景下也都是使用具體型別的方式,但是泛型還有其他非具體型別的定義方式,接下來我們繼續介紹一下泛型的非具體型別定義方式。

泛型可以定義在類上,也可以定義在方法上。

定義泛型類

下面就是一個泛型類的定義方式:

package com.zwx.coreJava.genericity;

import java.util.Map;

public class GenericClass<K,V,M> {
    private M name;
    private Map<K,V> map;

    public V test(M m){
        return null;
    }
}

定義的泛型可以只有一個,也可以定義多個,一般使用大寫字母來作為泛型定義,不同的字母之前也沒有什麼特殊含義,只不過一般預設的寫法都遵循以下默契:

  • 1、E表示元素型別
  • 2、K和V表示關鍵字與值的型別(比如map裡面的key和value)
  • 3、T則表示其他型別型別

PS:示例中我特意用了一個M來表示,就是想說明到底用什麼字母來表示泛型,並沒有語法要求。

定義泛型類的時候需要注意的是,類上定義的泛型不能使用在靜態變數和靜態方法上。比如上面的方法改成靜態方法則會編譯不透過,原因我們後面再解釋。

需要注意的是,介面也算是一種特殊的類,所以這些規則也適用於介面

定義泛型方法

如果我們不想在類上面定義泛型,只想在方法上定義泛型也可以,這就是泛型方法。泛型方法可以定義在泛型類裡面,也可以定義在普通類裡面
泛型方法的定義需要把<>放在修飾符(如public static)之後,返回值之前
如下就是一個泛型的定義示例:

package com.zwx.coreJava.genericity;

public class GenericMethod {
    public <T> T test(T arg){
        System.out.println("generic method");
        return null;
    }
}

那麼定義了泛型的方法應該如何呼叫呢?
我們把上面例子中的引數改為多引數看一下

package com.zwx.coreJava.genericity;

public class GenericMethod {
    public <T> T test(T...arg){
        System.out.println("generic method");
        return null;
    }

    public static void main(String[] args) {
        GenericMethod genericMethod = new GenericMethod();
        genericMethod.test("1",1);
    }
}

上面這段程式碼可以正常編譯輸出,並沒有起到限制的作用,所以如果非要限制,可以採用如下呼叫方式:

genericMethod.<String>test("1",1);

在方法前面加上泛型就可以起到限制作用,這時候程式碼就會編譯不通過了。

泛型的繼承

上面的泛型定義實際上並沒有太多限制,還是可以傳入任意型別,那麼假如我想限制一下泛型,比如說只能是某一個類的子類,又該如何定義呢?

如果想限定泛型為某一個類的子類,那麼就需要用到extends關鍵字。注意:泛型的繼承只能使用extends,而不能使用implements(即使是介面也只能用extends關鍵字)

package com.zwx.coreJava.genericity;

import java.io.Serializable;

public class GenericClass2<T extends Serializable>{
    public static void main(String[] args) {
        GenericClass2 genericClass2 = new GenericClass2<MyItem>();
    }
}

上面這個示例就會編譯不透過,因為我們的MyItem類並沒有實現Serializable介面,只有實現了Serializable介面的類才能被正常傳進去。

泛型的多繼承

在泛型裡面支援多繼承,可以透過“&”或者“,”來實現。

我們先看一個&的例子:

package com.zwx.coreJava.genericity;

import java.io.Serializable;

public class GenericClass2<T extends MyItem & Serializable & Cloneable>{
    public static void main(String[] args) {
        GenericClass2 genericClass2 = new GenericClass2<MyItemSub>();
    }
}

這裡要求必須只能有一個類,而且如果有一個類,那麼這個類必須放在第一位。如上面的例子,MyItem只能放在第一位。而下面這句話需要編譯透過,那麼MyItemSub必須是如下定義:

public class MyItemSub extends MyItem implements Serializable,Cloneable {
}

也就是說必須同時滿足所有條件。

接下來再看一個逗號的例子:

package com.zwx.coreJava.genericity;

public class GenericClass2<T extends MyItem,Serializable,Cloneable>{
    public static void main(String[] args) {
        GenericClass2 genericClass2 = new GenericClass2<MyItemSub,MyItemSub,MyItemSub>();
    }
}

但是這種寫法似乎只對第一個限制類型有用,後面的限制並沒有用上,因為我除了第1個引數,後面2個引數我傳任意型別都可以編譯透過。

泛型的繼承規則

我們新建一個類繼承MyItem:

package com.zwx.coreJava.genericity;

public class MyItemSub extends MyItem {
}

這時候我們再去測試一下這個例子:

package com.zwx.coreJava.genericity;

public class GenericClass3<T extends MyItem>{
    public static void main(String[] args) {
        MyItemSub myItemSub = new MyItemSub();
        MyItem myItem = myItemSub;//編譯透過

        GenericClass3<MyItemSub> myItemSubGenericClass = new GenericClass3<>();
        GenericClass3<MyItem> myItemGenericClass = myItemSubGenericClass;//編譯失敗
        
    }
}

可以看到最後這一句話編譯不透過,也就是說:GenericClass3<MyItem>和GenericClass3<MyItemSub>沒有任何關係(當然這個僅限於編譯階段),並不會因為泛型裡面有繼承關係就影響到了外面的繼承關係。

泛型萬用字元

在某些時候,我們可以透過萬用字元“?”來作為泛型,?表示不限制類型。(下面例子中Manager類是Employee的子類,兩個類都是空類,就不貼程式碼了

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard {
    public static void main(String[] args) {
        List<?> list = new ArrayList<>();
        list.add(null);//編譯透過
        list.add(1);//報錯
}

可以看到,雖然?表示允許任意型別,但是和List<Object>還是有本質區別的,使用萬用字元作為泛型的不能直接設定元素,除了null值
不過雖然不能直接設值,但是我們可以透過間接的方式設定值進去。

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard {
    public static void main(String[] args) {
        List<?> list = MyWildcard.init();
        Object obj = list.get(0);//透過
        list.add(new Employee());//不透過
    }

    public static List<?>  init(){
        List<Employee> list = new ArrayList<>();
        list.add(new Employee());
        return list;
    }
}

雖然我不能直接設定值進去,但是我可以get獲得list的元素。這是因為設定的時候無法確認?到底是什麼型別,所以Java會拒絕編譯,但是get元素的時候我可以直接賦值給Object,因為任何物件都是Object的子類,所以相當於知道了list內部物件的上界就是Object物件。用Object來接收不會有問題。

泛型萬用字元和extends關鍵字

萬用字元也可以使用extends關鍵字。

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard {
    public static void main(String[] args) {
        List<? extends Employee> list = MyWildcard.init();
        Employee employee = list.get(0);//透過
        list.add(new Manager());//不透過

    public static List<? extends Employee>  init(){
        List<Employee> list = new ArrayList<>();
        list.add(new Employee());
        return list;
    }
}

使用extends關鍵字和直接使用萬用字元區別不大,唯一的區別就是取值的時候我可以確定物件一定是Employee的子類,所以我可以直接使用Employee物件來接收。

換句話說就是:這種寫法我可以知道list內部元素的上界,但是我不知道你的下界,所以我只允許取值(用上界接收),不允許設值(設值要用下界)

泛型萬用字元和super關鍵字

萬用字元還可以使用super關鍵字,限定型別為某個類的超類:

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard {
    public static void main(String[] args) {
        List<? super Employee> list = MyWildcard.init();
        Employee employee = list.get(0);//不透過
        Object obj = list.get(0);//編譯透過
        list.add(new Employee());//透過
    }

    public static List<? super Employee>  init(){
        List<Employee> list = new ArrayList<>();
        list.add(new Employee());
        return list;
    }
}

可以看到,這裡就允許設值,因為super關鍵字限定了元素必須為Employee的父類,也就是我知道了元素的下限,所以我可以設值,但是取值因為不知道上界,所以只能用最頂層的Object。

T和?萬用字元的區別

這兩種表示方法有區別嗎?這兩個有本質的區別。總結一下主要有如下區別:

  • 1、T表示的是形參,也就是說如果我們想要用T,那麼必須要先定義才能用;而?萬用字元則表示的是實參,也就是說不需要定義,我就可以直接拿來使用。
  • 2、T相當於是佔位符,如果我們定義了T,而實際傳進去的是String,那麼實際的約束型別就是String型別,而不是T;而?萬用字元可以理解為就是一種真實存在的特殊型別。
  • 3、T可以使用多繼承,而?萬用字元不行,只能用單繼承
  • 4、T不能使用super關鍵字,而?萬用字元可以使用super關鍵字。
  • 5、?萬用字元表示的物件是存在繼承關係的,而T表示的不同泛型之間沒有任何關係,所以下面這個示例是成立的。
List<?> list = new ArrayList<>();
List<? extends Employee> list1 = new ArrayList<>();
list = list1;

泛型擦除

我們先看一個例子:

package com.zwx.coreJava.genericity.erasure;

import com.zwx.coreJava.genericity.wildcard.Employee;

import java.util.ArrayList;
import java.util.List;

public class TestErasure {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        List<Integer> list1 = new ArrayList<>();
        List<?> list2 = new ArrayList<>();

        System.out.println(list.equals(list1));//true
        System.out.println(list.equals(list2));//true
    }
}

兩句話的輸出結果都是true。

這是因為Java中的泛型只是在編譯階段有效,而實際執行之後會擦除掉,相當於沒有泛型,上面的3個list都等價於List list,所以Java中的的泛型並不是真正的泛型。

所以讓我們回到上面的例子,為什麼類泛型不能使用在靜態方法上?因為靜態方法不屬於某一個例項物件,而泛型在執行階段就被擦除了,那麼靜態方法在載入的時候根本就無法知道這個泛型到底是什麼型別。而非靜態方法是屬於例項物件,可以根據物件例項化狀態資訊得出泛型屬於什麼型別。

泛型和陣列

Java官方明確說明,不能例項化一個明確引數型別的陣列。
請看下面一個例子(ArrElement是一個空類):

package com.zwx.coreJava.genericity.array;

import java.util.ArrayList;
import java.util.List;

public class TestArray {
    public static void main(String[] args) {
        ArrElement<String>[] arr = new ArrElement<String>[10];//編譯不透過
        ArrElement<String>[] arr1 = new ArrElement[10];//編譯透過
        ArrElement<String>[] arr2 = (ArrElement<String>[])new ArrElement<?>[10];
    }
}

可以看到上面第1句話不允許編譯透過,而後面兩句話允許透過,這就是因為Java中禁止直接透過具體泛型來初始化一個數組,但是孕育透過具體泛型來接收一個數組。

那麼Java中為什麼要禁止透過實際型別來初始化陣列呢?
因為陣列在初始化之後就會記住資料的資料型別,但是泛型又能被擦出,這就會出現問題
比如上面這個例子中第一句話,泛型被擦除後,實際程式碼為:

ArrElement[] arr = new ArrElement[10];

那麼這時候假如我執行以下兩句程式碼:

Object[] objArr = arr;
objArr[0] = new ArrElement<Integer>();

這兩句話是完全可以透過陣列的安全性檢查的,但是這個元素型別和初始化的元素型別不一致,所以會導致型別錯誤。正是因為陣列會記住元素型別和泛型擦除導致了衝突,才禁止帶泛型初始化陣列,這樣陣列初始化的時候只會記住ArrElement物件,而不限定型別

總結

本文對Java泛型相關知識點進行了一個歸納整理,主要包括泛型類,泛型方法,多繼承,萬用字元和非萬用字元的區別,以及多繼承和陣列泛型相關知識點。

請關注我,和孤狼一起學習進步

本文章已修改原文用詞符合繁體字使用者習慣使其容易閱讀

版權宣告:此處為CSDN博主「雙子孤狼」的原創文章,依據CC 4.0 BY-SA版權協議,轉載請附上原文出處連結及本宣告。

原文連結:https://blog.csdn.net/zwx900102/article/details/109120992