一文全解Java泛型

一、引言：

Ja va早期版本里，集合容器直接拿Object存东西，根本管不了往里塞的是什么类型。开发的时候，啥类型都能往集合里扔，取出来的时候又得自己手动强转——代码写得啰嗦不说，运行时冷不丁就给你抛个ClassCastException，类型安全全靠祈祷。

为了解决类型不安全、强制转换繁琐、代码复用性差这几个老大难问题，Ja va 5正式引入了泛型机制。泛型的思路很直接：在类、接口、方法定义的时候先留个类型形参，等真正用的时候再指定具体类型，这样就把数据类型校验从运行时提前到了编译期。本质就是一套类型参数化的语法模板，既保证了编译期的类型安全，省去了手动强转的麻烦，又能写出通用的代码逻辑。正是这些优势，让泛型成了Ja va集合框架、工具类开发里不可或缺的核心特性。

换句话来说：没有泛型的时候，Ja va集合就像一个啥都能装的大箱子——你塞什么都行，取出来的时候还得自己分辨类型、手动转换，稍不注意就翻车。有了泛型，就可以给这个箱子规定好只能装某一种类型，编译时就把不对的类型挡在门外，取出来直接用，不用强转，更不会装错。除此之外，还能写出适配各种类型的通用工具类。这，就是泛型设计的初衷和价值。

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

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

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

优势

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

二、泛型类

泛型类的定义

用class名称后面加一个<泛型列表>来声明类，这种类就叫泛型类。

举个例子：class people

这里的people就是泛型类的名字，E是里面的泛型。说白了，定义的时候并不指明E具体是什么类型——它可以是任何类或者接口，唯独不能是基本数据类型。在类名后面加上 ，这个 E 就成了类型占位符，整个类里都可以拿 E 当类型来用，等到创建对象的时候再指定具体类型。

// 泛型类 
class Demo {
    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 d1 = new Demo<>();
        d1.set("Ja va");
        System.out.println(d1.get());
        // 传Integer类型
        Demo d2 = new Demo<>();
        d2.set(666);
        System.out.println(d2.get());
    }
}

核心特点

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

三、泛型方法

和普通类比起来，泛型类在声明和创建对象时，类名后面多了一对尖括号<>，而且必须用具体的类型替换掉<>里的泛型（或者用通配符？）。

1.使用具体类型

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

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

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

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

2.使用统配“？”

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

基础类：

// 父类
class Geometry{}
// 子类
class Circle extends Geometry{}
// 泛型类
class Cone{
    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

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

下界通配符 Cone

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

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

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

ConeconeOne

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

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

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

四、泛型接口

使用interface名称后面加<泛型列表>来声明一个接口，这就是泛型接口。

1、泛型接口定义格式

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

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

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

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

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

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

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

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

// 泛型接口
interface MyInterface {
    void show(E e);
}
// 实现类也带泛型，不指定具体类型
class Impl implements MyInterface {
    @Override
    public void show(E e) {
        System.out.println(e);
    }
}

Impl i1 = new Impl<>();
i1.show("张三");
Impl i2 = new Impl<>();
i2.show(666);

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

3、泛型接口核心

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

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

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

interface I {
    K getKey();
    V getValue();
}

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

五、类型擦除

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

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

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

Ja va 到底是怎么解决这个问题的？

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

1. 什么是类型擦除定义

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

通俗理解

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

编译时写的：

ArrayList list = new ArrayList<>();

编译后字节码里等价于：

ArrayList list = new ArrayList();

泛型 就这么被擦除消失了。

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

核心原理三步

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

示例：

• class Box → 擦除为 class Box