java 泛型

为解决类型不安全、强制转换繁琐、代码复用性差 等问题，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;
    }
}

java 复制代码

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

java 复制代码

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。

基础类：

java 复制代码

// 父类
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<?>

java 复制代码

// 可以接收任何类型
Cone<?> c1 = new Cone<>(new Circle());
Cone<?> c2 = new Cone<>(new Geometry());

// ✅ 可以读，只能拿到 Object
Object obj = c1.get();

// ❌ 不能写入任何数据
// c1.set(new Circle()); 编译报错

上界通配符 Cone<? extends Geometry>

java 复制代码

// 合法：本身、子类都可以
Cone<? extends Geometry> cone = new Cone<>(new Circle());

// ✅ 可读，读到的是 Geometry
Geometry g = cone.get();

// ❌ 不能往里存任何对象
// cone.set(new Circle()); 编译报错

下界通配符 Cone<? super Geometry>

java 复制代码

// 合法：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 子类 下界：收父类，可以写

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

java 复制代码

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> 演示）。

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

java 复制代码

// 父类
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; } // 读操作 
}

无界通配符 | ?

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

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

java 复制代码

// 无界通配符：可接收任意类型的 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");

上界通配符 | ? extends 上限类

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

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

java 复制代码

// 上界通配符：只能接收 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());

下界通配符 | ? super 下限类

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

核心特点：可以写（只能添加下限类的子类元素），读取时只能拿到 Object 类型（无法确定具体父类类型）。

java 复制代码

// 下界通配符：只能接收 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、超强记忆口诀

无界通配符 ?：随便收，只能读
上界通配符 ? extends：只出不进（只读不写）
下界通配符 ? super：只进不出（可写，读只能拿 Object）

4、高频避坑指南

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

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

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

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

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

java 复制代码

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

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

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

java 复制代码

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

5、总结

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

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

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

一、引言：

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

1.2有泛型

二、泛型类

三、泛型方法

1.使用具体类型

2.使用统配"？"

四、泛型接口

1、泛型接口定义格式

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

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

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

3、泛型接口核心

五、类型擦除

1. 什么是类型擦除定义

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

3.关键结论

六、泛型通配符

1、什么是泛型通配符？

2、三种泛型通配符

3、超强记忆口诀

4、高频避坑指南

5、总结

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