一文全解Java 泛型

一、引言：

在 Java 早期版本中，集合容器默认以Object类型存储所有对象，无法对存入的数据类型进行约束。开发时任意类型元素都可随意存入集合，取出元素时必须手动进行强制类型转换，不仅代码繁琐冗余，还极易引发运行时类型转换异常ClassCastException，程序类型安全性难以保障。

为解决类型不安全、强制转换繁琐、代码复用性差等问题，Java 5 正式引入泛型机制。泛型允许在类、接口、方法定义时设置类型形参，在使用时再指定具体实际类型，将数据类型由运行时校验提前到编译期校验。它本质是一套类型参数化的语法模板，既能保证程序编译期类型安全、省去手动类型强转，又能实现通用代码复用，大幅提升代码健壮性与可维护性，成为 Java 集合框架、工具类开发中不可或缺的核心特性。

也就是说：没有泛型时，Java 集合就像一个无差别大箱子，什么类型数据都能往里扔，取出来还要自己辨别、强制转换，容易出错。引入泛型后，可以给箱子规定只能装某一种类型，编译时就限制存入类型，不用强转、不会装错，还能写出适配所有类型的通用工具类，这就是泛型设计的初衷与价值。

1.1没有泛型（JDK5 之前写法）

底层默认存 Object，无类型限制、要手动强转、容易报运行时异常

import java.util.ArrayList;
public class NoGenericDemo {
    public static void main(String[] args) {
        // 没有泛型，集合可以随便存任何对象
        ArrayList list = new ArrayList();
        list.add("张三");
        list.add(123);  // 故意存整数，和字符串混存
        // 取值必须手动强制类型转换
        String name = (String) list.get(0);
        System.out.println(name);
        // 运行时报错：ClassCastException
        String num = (String) list.get(1);
    }
}

痛点

• 能随意存入不同类型，编译不报错；
• 取值必须手动强转；
• 类型不匹配，运行才崩溃，隐患大。

1.2有泛型

指定集合只能存 String，编译期类型检查、无需强转、杜绝类型混乱

import java.util.ArrayList;
public class HasGenericDemo {
    public static void main(String[] args) {
        // 泛型限定：只能存String类型
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        // list.add(123);  // 直接编译报错！不让存，从根源杜绝错误
        // 取值不用强制转换，编译器自动处理
        String name = list.get(0);
        System.out.println(name);
    }
}

优势

• 编译期就限制类型，错误写代码时就发现；
• 取值不用手动强转；
• 类型安全，不会出现 ClassCastException。

二、泛型类

泛型类的定义

可以使用class名称<泛型列表>声明一个类，这样的类称之为泛型类 

例如：class people <E>

其中，people是泛型类的名称，E是其中的泛型，也就是说并没有指定E是何种类型的数据，它可以是任何类或接口，但不能是基本数据类型。在类名后面加 <E>，E 是类型占位符，整个类都可以用 E 当类型用，创建对象时再指定具体类型。

// 泛型类 <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());
    }
}

核心特点

• MyBox<E> 是泛型类，<E> 声明类型占位符；
• 同一个类，可以复用给 String、Integer、自定义对象；
• 编译期类型约束，存错类型直接报错；
• 取值不用强制类型转换

三、泛型方法

和普通的类相比，泛型类声明和创建对象时，类名后多了一对<>，而且要用具体的类型替换<>中的泛型（或使用统配“？”）

1.使用具体类型

格式：泛型类<具体类型> 变量名 = new 泛型类<>(构造参数);

用具体类型替换<>中的泛型，例如，用具体类型circle替换泛型E

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

• Cone<E> 是一个泛型类，E 是类型参数。
• 声明变量时，Cone<Circle> 表示：这个 coneOne 只能存 Circle 类型的对象。
• 不能写 Cone<E> coneOne;，因为 E 只是类定义里的占位符，创建对象时必须用具体类型替换它。
• 创建对象时，new Cone<Circle> 后面的类型，要和前面声明的类型一致（JDK7+ 也可以写成 new Cone<>(circle)，编译器会自动推断）。

2.使用统配“？”

• 无界通配符：Cone<?> cone，表示任意类型的 Cone，等价于 Cone<? extends Object>。
• 上界通配符：Cone<? extends Geometry> cone
  • 含义：只能接收类型为 Cone<Geometry> 或 Cone<Geometry子类> 的对象。
  • 限制：只能读、不能写（编译器不知道具体子类型，禁止写入）。
• 下界通配符：Cone<? super Geometry> cone
  • 含义：只能接收类型为 Cone<Geometry> 或 Cone<Geometry父类> 的对象。
  • 限制：只能写、读时只能拿到 Object。

基础类：

// 父类
class Geometry{}
// 子类
class Circle extends Geometry{}
// 泛型类
class Cone<E>{
    private E e;
    public Cone(E e){ this.e = e; }
    // 设值
    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();
// ❌ 不能写入任何数据
// c1.set(new Circle()); 编译报错

上界通配符 Cone<? extends Geometry>

// 合法：本身、子类都可以
Cone<? extends Geometry> cone = new Cone<>(new Circle());
// ✅ 可读，读到的是 Geometry
Geometry g = cone.get();
// ❌ 不能往里存任何对象
// cone.set(new Circle()); 编译报错

下界通配符 Cone<? super Geometry>

// 合法：Geometry、父类Object都行
Cone<? super Geometry> cone = new Cone<>(new Geometry());
// ✅ 可以写入子类对象
cone.set(new Circle());
// ✅ 能读，但只能用 Object 接收
Object obj = cone.get();
// ❌ 不能用 Geometry 接收
// Geometry g = cone.get(); 编译报错

• ? 无界：随便收，只能读
• ? extends 父类 上界：收子类，只能读
• ? super 子类 下界：收父类，可以写

泛型类声明对象时可以用通配符“？”来限制泛型的范围。

Cone<? extends Geometry>coneOne

如果 Geometry 类是类，那么 “<? extends Geometry>” 中的 “? extends Geometry” 表示任何 Geometry 类的子类或 Geometry 类本身（可理解为泛型 E 被限制了范围）；如果 Geometry 是接口，那么 “<? extends Geometry>” 中的 “? extends Geometry” 表示任何实现 Geometry 接口的类。

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

• 限制 Cone 里的类型，必须是 Geometry 本身，或者它的子类（如果 Geometry 是接口，就是实现它的类）。
• 注意：? 不是类型变量，只是 “未知类型” 的占位符，不能用它定义泛型类，只能用在声明变量、方法参数上。

四、泛型接口

可以使用interface名称<泛型列表>声明一个接口，这样声明的接口称作泛型接口

1、泛型接口定义格式

// 接口后加 <E> 泛型标识
public interface 接口名<E> {
    E get();
    void set(E e);
}

本质：和泛型类一样，把类型做成参数，让接口方法的参数、返回值统一由泛型约束。

2、泛型接口两种实现方式

方式 1：实现类明确指定泛型具体类型

// 1. 定义泛型接口
interface MyInterface<E> {
    void show(E e);
}
// 2. 实现类直接写死类型：固定为 String
class Impl implements MyInterface<String> {
    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

Impl impl = new Impl();
impl.show("泛型接口测试");

特点：实现类类型固定，只能用一种类型。

方式 2：实现类也定义为泛型类，保留泛型<E>

// 泛型接口
interface MyInterface<E> {
    void show(E e);
}
// 实现类也带泛型，不指定具体类型
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);

特点：实现类也是泛型，一套实现适配多种类型。

3、泛型接口核心

• 定义格式接口名后跟 <E>，接口中抽象方法可以用 E 作参数 / 返回值。
• 两种实现方式
  • 实现类指定具体类型：实现类类型固定；
  • 实现类保留泛型<E>：实现类也是泛型，可复用。
• 泛型接口也能加边界限制

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

• 多泛型接口可以同时定义多个泛型：

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

• 特点总结
• 接口抽象方法的参数、返回值可以由泛型统一约束；
• 兼顾接口规范 + 泛型类型安全、代码复用；
• 集合里 Iterable<E>、Collection<E>、List<E> 全是泛型接口。

五、类型擦除

假如我们定义了一个 ArrayList< Integer > 泛型集合，若向该集合中插入 String 类型的对象，不需要运行程序，编译器就会直接报错。这里可能有小伙伴就产生了疑问：

不是说泛型信息在编译的时候就会被擦除掉吗？那既然泛型信息被擦除了，如何保证我们在集合中只添加指定的数据类型的对象呢？

换而言之，我们虽然定义了 ArrayList< Integer > 泛型集合，但其泛型信息最终被擦除后就变成了 ArrayList< Object > 集合，那为什么不允许向其中插入 String 对象呢？

Java 是如何解决这个问题的？

其实在创建一个泛型类的对象时， Java 编译器是先检查代码中传入 < T > 的数据类型，并记录下来，然后再对代码进行编译，编译的同时进行类型擦除；如果需要对被擦除了泛型信息的对象进行操作，编译器会自动将对象进行类型转换。

1. 什么是类型擦除定义

泛型只在编译阶段有效，编译通过后，进入运行阶段时，JVM 会把代码中所有泛型标识 <E>、<String>、<Integer> 全部抹掉，变回原始类型 Object（或指定上界类型），这个过程就叫类型擦除 。

通俗理解

• 编译时：泛型是给编译器看的，做类型检查、约束类型；
• 运行时：JVM 不认识泛型，把所有泛型标记全部擦掉，变回普通类、普通集合。

编译写的：

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

编译后字节码里等价于：

ArrayList list = new ArrayList();

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

2. 类型擦除的原理（底层机制）

核心原理三步

• 第一步：编译期语法检查编译器根据泛型 <E> 约束：
  • 只能存指定类型；
  • 报错类型不匹配的代码；
  • 自动帮你补上隐式强制类型转换。
• 第二步：擦除泛型参数
  • 无边界泛型 <E> → 直接擦除为 Object
  • 有边界泛型 <E extends 父类> → 擦除为 父类类型

示例：

• class Box<E> 👉 擦除为 class Box<Object>
• class Box<E extends Geometry> 👉 擦除为 class Box<Geometry>
• 第三步：运行时只剩原始类型运行时：
• ArrayList<String>、ArrayList<Integer> 本质是同一个 ArrayList 类
• 不会因为泛型不同，生成新的类字节码
• 泛型仅仅是编译期语法糖，运行无泛型

3.关键结论

• 泛型是编译期概念，运行不存在泛型；
• 类型擦除后，泛型类型变回 Object 或其上界父类；
• List<String> 和 List<Integer> 运行时是同一个类型；
• 为什么不能用 instanceof 判断泛型？因为运行时泛型已经被擦掉了，识别不了具体泛型类型。

六、泛型通配符

1、什么是泛型通配符？

泛型通配符用 ? 表示，是一种「不确定的泛型类型占位符」，核心用途是：

• 接收未知的泛型类型，适配多种泛型场景
• 限制泛型类型的范围，保证类型安全

关键注意：通配符 ? 只能用在「变量声明」「方法参数」上，不能用来定义泛型类、泛型接口（比如 class A<?> {} 是错误写法）。

2、三种泛型通配符

泛型通配符分为三种，核心区别在于「类型范围限制」和「读写权限」，我们结合代码示例逐一讲解（以下示例均基于父类Geometry、子类 Circle 和泛型类 Cone<E> 演示）。

基础准备（所有示例共用）

// 父类
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. 无界通配符 | ?

含义：无任何类型限制，可以接收「任意泛型类型」，等价于 ? extends Object。

核心特点：只能读，不能写（无法确定具体类型，为保证安全，禁止添加任何元素）。

// 无界通配符：可接收任意类型的 Cone 
Cone<?> cone1 = new Cone<>(new Circle()); 
Cone<?> cone2 = new Cone<>("测试"); 
Cone<?> cone3 = new Cone<>(123); // ✅ 可读：读取结果统一为 Object 类型 
Object obj = cone1.get(); 
// ❌ 不可写：无论添加什么类型，都会编译报错 
// cone1.set(new Circle()); 
// cone1.set("abc");

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

含义：限制泛型类型必须是「上限类本身，或上限类的子类」（本文以上限类 Geometry 为例）。

核心特点：只能读，不能写（编译器无法确定具体是哪种子类，禁止添加元素，避免类型混乱）。

// 上界通配符：只能接收 Cone<Geometry> 或 Cone<Circle>（子类） 
Cone<? extends Geometry> cone = new Cone<>(new Circle()); 
// ✅ 可读：读取结果为上限类 Geometry 类型（无需强转） 
Geometry g = cone.get(); 
// ❌ 不可写：即使添加子类 Circle，也会编译报错 
// cone.set(new Circle()); 
// cone.set(new Geometry());

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

含义：限制泛型类型必须是「下限类本身，或下限类的父类」（本文以下限类 Geometry 为例）。

核心特点：可以写（只能添加下限类的子类元素），读取时只能拿到 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(); 
// ❌ 错误写法：不能用 Geometry 接收读取结果 
// Geometry g = cone.get();

3、超强记忆口诀

1. 无界通配符 ?：随便收，只能读

2. 上界通配符 ? extends：只出不进（只读不写）

3. 下界通配符 ? super：只进不出（可写，读只能拿 Object）

4、高频避坑指南

避坑1：通配符不能定义泛型类/接口

// ❌ 错误：不能用 ? 定义泛型类 public class Cone<?> {}

正确写法：用泛型标识（E、T、K 等）定义，通配符只用于使用时。

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

即使Circle 是 Geometry 的子类，Cone<Circle> 也不是Cone<Geometry> 的子类，直接赋值会报错：

// ❌ 错误：泛型无继承性 
Cone<Geometry> cone = new Cone<>(new Circle()); 
// ✅ 正确：用上界通配符兼容 
Cone<? extends Geometry> cone = new Cone<>(new Circle());

避坑3：运行时泛型擦除，通配符也会被擦除

运行时，JVM 不认识泛型和通配符，所有泛型标识（包括 ?）都会被擦除，变回原始类型（Object 或上界类）。因此，无法用 instanceof 判断泛型类型：

// ❌ 错误：编译报错，无法判断泛型类型 
if (cone instanceof Cone<Circle>) {}

5、总结

泛型通配符的核心是「不确定类型的占位」，三种通配符的核心区别在于「类型范围」和「读写权限」：

• 无界 ?：适配所有类型，只读
• 上界 ? extends：限制子类范围，只读
• 下界 ? super：限制父类范围，可写（子类）、读Object

实际开发中，上界通配符常用于「读取数据」（比如遍历集合），下界通配符常用于「写入数据」（比如往集合中添加元素），掌握这个核心场景，就能灵活运用通配符啦

到此这篇关于一文全解Java 泛型的文章就介绍到这了,更多相关java 泛型内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论