一、引言：

在 Java 早期版本中，集合容器默認(rèn)以Object類型存儲(chǔ)所有對(duì)象，無法對(duì)存入的數(shù)據(jù)類型進(jìn)行約束。開發(fā)時(shí)任意類型元素都可隨意存入集合，取出元素時(shí)必須手動(dòng)進(jìn)行強(qiáng)制類型轉(zhuǎn)換，不僅代碼繁瑣冗余，還極易引發(fā)運(yùn)行時(shí)類型轉(zhuǎn)換異常ClassCastException，程序類型安全性難以保障。

為解決類型不安全、強(qiáng)制轉(zhuǎn)換繁瑣、代碼復(fù)用性差等問題，Java 5 正式引入泛型機(jī)制。泛型允許在類、接口、方法定義時(shí)設(shè)置類型形參，在使用時(shí)再指定具體實(shí)際類型，將數(shù)據(jù)類型由運(yùn)行時(shí)校驗(yàn)提前到編譯期校驗(yàn)。它本質(zhì)是一套類型參數(shù)化的語法模板，既能保證程序編譯期類型安全、省去手動(dòng)類型強(qiáng)轉(zhuǎn)，又能實(shí)現(xiàn)通用代碼復(fù)用，大幅提升代碼健壯性與可維護(hù)性，成為 Java 集合框架、工具類開發(fā)中不可或缺的核心特性。

也就是說：沒有泛型時(shí)，Java 集合就像一個(gè)無差別大箱子，什么類型數(shù)據(jù)都能往里扔，取出來還要自己辨別、強(qiáng)制轉(zhuǎn)換，容易出錯(cuò)。引入泛型后，可以給箱子規(guī)定只能裝某一種類型，編譯時(shí)就限制存入類型，不用強(qiáng)轉(zhuǎn)、不會(huì)裝錯(cuò)，還能寫出適配所有類型的通用工具類，這就是泛型設(shè)計(jì)的初衷與價(jià)值。

1.1沒有泛型（JDK5 之前寫法）

底層默認(rèn)存 Object，無類型限制、要手動(dòng)強(qiáng)轉(zhuǎn)、容易報(bào)運(yùn)行時(shí)異常

import java.util.ArrayList;
public class NoGenericDemo {
    public static void main(String[] args) {
        // 沒有泛型，集合可以隨便存任何對(duì)象
        ArrayList list = new ArrayList();
        list.add("張三");
        list.add(123);  // 故意存整數(shù)，和字符串混存
        // 取值必須手動(dòng)強(qiáng)制類型轉(zhuǎn)換
        String name = (String) list.get(0);
        System.out.println(name);
        // 運(yùn)行時(shí)報(bào)錯(cuò)：ClassCastException
        String num = (String) list.get(1);
    }
}

痛點(diǎn)

• 能隨意存入不同類型，編譯不報(bào)錯(cuò)；
• 取值必須手動(dòng)強(qiáng)轉(zhuǎn)；
• 類型不匹配，運(yùn)行才崩潰，隱患大。

1.2有泛型

指定集合只能存 String，編譯期類型檢查、無需強(qiáng)轉(zhuǎn)、杜絕類型混亂

import java.util.ArrayList;
public class HasGenericDemo {
    public static void main(String[] args) {
        // 泛型限定：只能存String類型
        ArrayList<String> list = new ArrayList<>();
        list.add("張三");
        // list.add(123);  // 直接編譯報(bào)錯(cuò)！不讓存，從根源杜絕錯(cuò)誤
        // 取值不用強(qiáng)制轉(zhuǎn)換，編譯器自動(dòng)處理
        String name = list.get(0);
        System.out.println(name);
    }
}

優(yōu)勢(shì)

• 編譯期就限制類型，錯(cuò)誤寫代碼時(shí)就發(fā)現(xiàn)；
• 取值不用手動(dòng)強(qiáng)轉(zhuǎn)；
• 類型安全，不會(huì)出現(xiàn) ClassCastException。

二、泛型類

泛型類的定義

可以使用class名稱<泛型列表>聲明一個(gè)類，這樣的類稱之為泛型類 

例如：class people <E>

其中，people是泛型類的名稱，E是其中的泛型，也就是說并沒有指定E是何種類型的數(shù)據(jù)，它可以是任何類或接口，但不能是基本數(shù)據(jù)類型。在類名后面加 <E>，E 是類型占位符，整個(gè)類都可以用 E 當(dāng)類型用，創(chuàng)建對(duì)象時(shí)再指定具體類型。

// 泛型類 <E>
class Demo<E> {
    private E num;
    public void set(E num) {
        this.num = num;
    }
    public E get() {
        return num;
    }
}

public class Test {
    public static void main(String[] args) {
        // 傳String類型
        Demo<String> d1 = new Demo<>();
        d1.set("Java");
        System.out.println(d1.get());
        // 傳Integer類型
        Demo<Integer> d2 = new Demo<>();
        d2.set(666);
        System.out.println(d2.get());
    }
}

核心特點(diǎn)

• MyBox<E> 是泛型類，<E> 聲明類型占位符；
• 同一個(gè)類，可以復(fù)用給 String、Integer、自定義對(duì)象；
• 編譯期類型約束，存錯(cuò)類型直接報(bào)錯(cuò)；
• 取值不用強(qiáng)制類型轉(zhuǎn)換

三、泛型方法

和普通的類相比，泛型類聲明和創(chuàng)建對(duì)象時(shí)，類名后多了一對(duì)<>，而且要用具體的類型替換<>中的泛型（或使用統(tǒng)配“？”）

1.使用具體類型

格式：泛型類<具體類型> 變量名 = new 泛型類<>(構(gòu)造參數(shù));

用具體類型替換<>中的泛型，例如，用具體類型circle替換泛型E

Circle circle =new Circle();
Cone<Circle>coneOne;//用具體類型Circle，不可以用泛型E：cone<E>coneOne;
coneOne=new Cone<Circle>(circle);

• Cone<E> 是一個(gè)泛型類，E 是類型參數(shù)。
• 聲明變量時(shí)，Cone<Circle> 表示：這個(gè) coneOne 只能存 Circle 類型的對(duì)象。
• 不能寫 Cone<E> coneOne;，因?yàn)?E 只是類定義里的占位符，創(chuàng)建對(duì)象時(shí)必須用具體類型替換它。
• 創(chuàng)建對(duì)象時(shí)，new Cone<Circle> 后面的類型，要和前面聲明的類型一致（JDK7+ 也可以寫成 new Cone<>(circle)，編譯器會(huì)自動(dòng)推斷）。

2.使用統(tǒng)配“？”

• 無界通配符：Cone<?> cone，表示任意類型的 Cone，等價(jià)于 Cone<? extends Object>。
• 上界通配符：Cone<? extends Geometry> cone
  • 含義：只能接收類型為 Cone<Geometry> 或 Cone<Geometry子類> 的對(duì)象。
  • 限制：只能讀、不能寫（編譯器不知道具體子類型，禁止寫入）。
• 下界通配符：Cone<? super Geometry> cone
  • 含義：只能接收類型為 Cone<Geometry> 或 Cone<Geometry父類> 的對(duì)象。
  • 限制：只能寫、讀時(shí)只能拿到 Object。

基礎(chǔ)類：

// 父類
class Geometry{}
// 子類
class Circle extends Geometry{}
// 泛型類
class Cone<E>{
    private E e;
    public Cone(E e){ this.e = e; }
    // 設(shè)值
    public void set(E e){ this.e = e; }
    // 取值
    public E get(){ return e; }
}

無界通配符 Cone<?>

// 可以接收任何類型
Cone<?> c1 = new Cone<>(new Circle());
Cone<?> c2 = new Cone<>(new Geometry());
// ? 可以讀，只能拿到 Object
Object obj = c1.get();
// ? 不能寫入任何數(shù)據(jù)
// c1.set(new Circle()); 編譯報(bào)錯(cuò)

上界通配符 Cone<? extends Geometry>

// 合法：本身、子類都可以
Cone<? extends Geometry> cone = new Cone<>(new Circle());
// ? 可讀，讀到的是 Geometry
Geometry g = cone.get();
// ? 不能往里存任何對(duì)象
// cone.set(new Circle()); 編譯報(bào)錯(cuò)

下界通配符 Cone<? super Geometry>

// 合法：Geometry、父類Object都行
Cone<? super Geometry> cone = new Cone<>(new Geometry());
// ? 可以寫入子類對(duì)象
cone.set(new Circle());
// ? 能讀，但只能用 Object 接收
Object obj = cone.get();
// ? 不能用 Geometry 接收
// Geometry g = cone.get(); 編譯報(bào)錯(cuò)

• ? 無界：隨便收，只能讀
• ? extends 父類 上界：收子類，只能讀
• ? super 子類 下界：收父類，可以寫

泛型類聲明對(duì)象時(shí)可以用通配符“？”來限制泛型的范圍。

Cone<? extends Geometry>coneOne

如果 Geometry 類是類，那么 “<? extends Geometry>” 中的 “? extends Geometry” 表示任何 Geometry 類的子類或 Geometry 類本身（可理解為泛型 E 被限制了范圍）；如果 Geometry 是接口，那么 “<? extends Geometry>” 中的 “? extends Geometry” 表示任何實(shí)現(xiàn) Geometry 接口的類。

這里的 ? extends Geometry 叫上界通配符，作用是：

• 限制 Cone 里的類型，必須是 Geometry 本身，或者它的子類（如果 Geometry 是接口，就是實(shí)現(xiàn)它的類）。
• 注意：? 不是類型變量，只是 “未知類型” 的占位符，不能用它定義泛型類，只能用在聲明變量、方法參數(shù)上。

四、泛型接口

可以使用interface名稱<泛型列表>聲明一個(gè)接口，這樣聲明的接口稱作泛型接口

1、泛型接口定義格式

// 接口后加 <E> 泛型標(biāo)識(shí)
public interface 接口名<E> {
    E get();
    void set(E e);
}

本質(zhì)：和泛型類一樣，把類型做成參數(shù)，讓接口方法的參數(shù)、返回值統(tǒng)一由泛型約束。

2、泛型接口兩種實(shí)現(xiàn)方式

方式 1：實(shí)現(xiàn)類明確指定泛型具體類型

// 1. 定義泛型接口
interface MyInterface<E> {
    void show(E e);
}
// 2. 實(shí)現(xiàn)類直接寫死類型：固定為 String
class Impl implements MyInterface<String> {
    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

Impl impl = new Impl();
impl.show("泛型接口測(cè)試");

特點(diǎn)：實(shí)現(xiàn)類類型固定，只能用一種類型。

方式 2：實(shí)現(xiàn)類也定義為泛型類，保留泛型<E>

// 泛型接口
interface MyInterface<E> {
    void show(E e);
}
// 實(shí)現(xiàn)類也帶泛型，不指定具體類型
class Impl<E> implements MyInterface<E> {
    @Override
    public void show(E e) {
        System.out.println(e);
    }
}

Impl<String> i1 = new Impl<>();
i1.show("張三");
Impl<Integer> i2 = new Impl<>();
i2.show(666);

特點(diǎn)：實(shí)現(xiàn)類也是泛型，一套實(shí)現(xiàn)適配多種類型。

3、泛型接口核心

• 定義格式接口名后跟 <E>，接口中抽象方法可以用 E 作參數(shù) / 返回值。
• 兩種實(shí)現(xiàn)方式
  • 實(shí)現(xiàn)類指定具體類型：實(shí)現(xiàn)類類型固定；
  • 實(shí)現(xiàn)類保留泛型<E>：實(shí)現(xiàn)類也是泛型，可復(fù)用。
• 泛型接口也能加邊界限制

// 限制E只能是Geometry或子類
interface MyInterface<E extends Geometry> {
    E get();
}

• 多泛型接口可以同時(shí)定義多個(gè)泛型：

interface I<K,V> {
    K getKey();
    V getValue();
}

• 特點(diǎn)總結(jié)
• 接口抽象方法的參數(shù)、返回值可以由泛型統(tǒng)一約束；
• 兼顧接口規(guī)范 + 泛型類型安全、代碼復(fù)用；
• 集合里 Iterable<E>、Collection<E>、List<E> 全是泛型接口。

五、類型擦除

假如我們定義了一個(gè) ArrayList< Integer > 泛型集合，若向該集合中插入 String 類型的對(duì)象，不需要運(yùn)行程序，編譯器就會(huì)直接報(bào)錯(cuò)。這里可能有小伙伴就產(chǎn)生了疑問：

不是說泛型信息在編譯的時(shí)候就會(huì)被擦除掉嗎？那既然泛型信息被擦除了，如何保證我們?cè)诩现兄惶砑又付ǖ臄?shù)據(jù)類型的對(duì)象呢？

換而言之，我們雖然定義了 ArrayList< Integer > 泛型集合，但其泛型信息最終被擦除后就變成了 ArrayList< Object > 集合，那為什么不允許向其中插入 String 對(duì)象呢？

Java 是如何解決這個(gè)問題的？

其實(shí)在創(chuàng)建一個(gè)泛型類的對(duì)象時(shí)， Java 編譯器是先檢查代碼中傳入 < T > 的數(shù)據(jù)類型，并記錄下來，然后再對(duì)代碼進(jìn)行編譯，編譯的同時(shí)進(jìn)行類型擦除；如果需要對(duì)被擦除了泛型信息的對(duì)象進(jìn)行操作，編譯器會(huì)自動(dòng)將對(duì)象進(jìn)行類型轉(zhuǎn)換。

1. 什么是類型擦除定義

泛型只在編譯階段有效，編譯通過后，進(jìn)入運(yùn)行階段時(shí)，JVM 會(huì)把代碼中所有泛型標(biāo)識(shí) <E>、<String>、<Integer> 全部抹掉，變回原始類型 Object（或指定上界類型），這個(gè)過程就叫類型擦除 。

通俗理解

• 編譯時(shí)：泛型是給編譯器看的，做類型檢查、約束類型；
• 運(yùn)行時(shí)：JVM 不認(rèn)識(shí)泛型，把所有泛型標(biāo)記全部擦掉，變回普通類、普通集合。

編譯寫的：

ArrayList<String> list = new ArrayList<>();

編譯后字節(jié)碼里等價(jià)于：

ArrayList list = new ArrayList();

泛型 <String> 被擦除消失了。

2. 類型擦除的原理（底層機(jī)制）

核心原理三步

• 第一步：編譯期語法檢查編譯器根據(jù)泛型 <E> 約束：
  • 只能存指定類型；
  • 報(bào)錯(cuò)類型不匹配的代碼；
  • 自動(dòng)幫你補(bǔ)上隱式強(qiáng)制類型轉(zhuǎn)換。
• 第二步：擦除泛型參數(shù)
  • 無邊界泛型 <E> → 直接擦除為 Object
  • 有邊界泛型 <E extends 父類> → 擦除為 父類類型

示例：

• class Box<E> ?? 擦除為 class Box<Object>
• class Box<E extends Geometry> ?? 擦除為 class Box<Geometry>
• 第三步：運(yùn)行時(shí)只剩原始類型運(yùn)行時(shí)：
• ArrayList<String>、ArrayList<Integer> 本質(zhì)是同一個(gè) ArrayList 類
• 不會(huì)因?yàn)榉盒筒煌?，生成新的類字?jié)碼
• 泛型僅僅是編譯期語法糖，運(yùn)行無泛型

3.關(guān)鍵結(jié)論

• 泛型是編譯期概念，運(yùn)行不存在泛型；
• 類型擦除后，泛型類型變回 Object 或其上界父類；
• List<String> 和 List<Integer> 運(yùn)行時(shí)是同一個(gè)類型；
• 為什么不能用 instanceof 判斷泛型？因?yàn)檫\(yùn)行時(shí)泛型已經(jīng)被擦掉了，識(shí)別不了具體泛型類型。

六、泛型通配符

1、什么是泛型通配符？

泛型通配符用 ? 表示，是一種「不確定的泛型類型占位符」，核心用途是：

• 接收未知的泛型類型，適配多種泛型場(chǎng)景
• 限制泛型類型的范圍，保證類型安全

關(guān)鍵注意：通配符 ? 只能用在「變量聲明」「方法參數(shù)」上，不能用來定義泛型類、泛型接口（比如 class A<?> {} 是錯(cuò)誤寫法）。

2、三種泛型通配符

泛型通配符分為三種，核心區(qū)別在于「類型范圍限制」和「讀寫權(quán)限」，我們結(jié)合代碼示例逐一講解（以下示例均基于父類Geometry、子類 Circle 和泛型類 Cone<E> 演示）。

基礎(chǔ)準(zhǔn)備（所有示例共用）

// 父類
class Geometry {} 
// 子類 
class Circle extends Geometry {} 
// 泛型類 
class Cone<E> {
 private E element; public Cone(E element) {
 this.element = element; } 
public void set(E element) { 
this.element = element; } 
// 寫操作 
public E get() {
 return element; } // 讀操作 
}

1. 無界通配符 | ?

含義：無任何類型限制，可以接收「任意泛型類型」，等價(jià)于 ? extends Object。

核心特點(diǎn)：只能讀，不能寫（無法確定具體類型，為保證安全，禁止添加任何元素）。

// 無界通配符：可接收任意類型的 Cone 
Cone<?> cone1 = new Cone<>(new Circle()); 
Cone<?> cone2 = new Cone<>("測(cè)試"); 
Cone<?> cone3 = new Cone<>(123); // ? 可讀：讀取結(jié)果統(tǒng)一為 Object 類型 
Object obj = cone1.get(); 
// ? 不可寫：無論添加什么類型，都會(huì)編譯報(bào)錯(cuò) 
// cone1.set(new Circle()); 
// cone1.set("abc");

2. 上界通配符 | ? extends 上限類

含義：限制泛型類型必須是「上限類本身，或上限類的子類」（本文以上限類 Geometry 為例）。

核心特點(diǎn)：只能讀，不能寫（編譯器無法確定具體是哪種子類，禁止添加元素，避免類型混亂）。

// 上界通配符：只能接收 Cone<Geometry> 或 Cone<Circle>（子類） 
Cone<? extends Geometry> cone = new Cone<>(new Circle()); 
// ? 可讀：讀取結(jié)果為上限類 Geometry 類型（無需強(qiáng)轉(zhuǎn)） 
Geometry g = cone.get(); 
// ? 不可寫：即使添加子類 Circle，也會(huì)編譯報(bào)錯(cuò) 
// cone.set(new Circle()); 
// cone.set(new Geometry());

3. 下界通配符 | ? super 下限類

含義：限制泛型類型必須是「下限類本身，或下限類的父類」（本文以下限類 Geometry 為例）。

核心特點(diǎn)：可以寫（只能添加下限類的子類元素），讀取時(shí)只能拿到 Object 類型（無法確定具體父類類型）。

// 下界通配符：只能接收 Cone<Geometry> 或 Cone<Object>（父類） 
Cone<? super Geometry> cone = new Cone<>(new Geometry()); 
// ? 可寫：只能添加下限類的子類（Circle 是 Geometry 的子類） 
cone.set(new Circle()); 
// ? 可讀：只能用 Object 接收，無法直接用 Geometry 接收 
Object obj = cone.get(); 
// ? 錯(cuò)誤寫法：不能用 Geometry 接收讀取結(jié)果 
// Geometry g = cone.get();

3、超強(qiáng)記憶口訣

1. 無界通配符 ?：隨便收，只能讀

2. 上界通配符 ? extends：只出不進(jìn)（只讀不寫）

3. 下界通配符 ? super：只進(jìn)不出（可寫，讀只能拿 Object）

4、高頻避坑指南

避坑1：通配符不能定義泛型類/接口

// ? 錯(cuò)誤：不能用 ? 定義泛型類 public class Cone<?> {}

正確寫法：用泛型標(biāo)識(shí)（E、T、K 等）定義，通配符只用于使用時(shí)。

避坑2：泛型無繼承性，需用通配符兼容

即使Circle 是 Geometry 的子類，Cone<Circle> 也不是Cone<Geometry> 的子類，直接賦值會(huì)報(bào)錯(cuò)：

// ? 錯(cuò)誤：泛型無繼承性 
Cone<Geometry> cone = new Cone<>(new Circle()); 
// ? 正確：用上界通配符兼容 
Cone<? extends Geometry> cone = new Cone<>(new Circle());

避坑3：運(yùn)行時(shí)泛型擦除，通配符也會(huì)被擦除

運(yùn)行時(shí)，JVM 不認(rèn)識(shí)泛型和通配符，所有泛型標(biāo)識(shí)（包括 ?）都會(huì)被擦除，變回原始類型（Object 或上界類）。因此，無法用 instanceof 判斷泛型類型：

// ? 錯(cuò)誤：編譯報(bào)錯(cuò)，無法判斷泛型類型 
if (cone instanceof Cone<Circle>) {}

5、總結(jié)

泛型通配符的核心是「不確定類型的占位」，三種通配符的核心區(qū)別在于「類型范圍」和「讀寫權(quán)限」：

• 無界 ?：適配所有類型，只讀
• 上界 ? extends：限制子類范圍，只讀
• 下界 ? super：限制父類范圍，可寫（子類）、讀Object

實(shí)際開發(fā)中，上界通配符常用于「讀取數(shù)據(jù)」（比如遍歷集合），下界通配符常用于「寫入數(shù)據(jù)」（比如往集合中添加元素），掌握這個(gè)核心場(chǎng)景，就能靈活運(yùn)用通配符啦

到此這篇關(guān)于一文全解Java 泛型的文章就介紹到這了,更多相關(guān)java 泛型內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論