Java 泛型:泛型类、泛型方法、泛型接口与通配符

目录

一、泛型

二、泛型类

三、泛型方法

四、泛型接口

五、泛型通配符

[1. 无界通配符](#1. 无界通配符)

[2. 上界通配符](#2. 上界通配符)

[3. 下界通配符](#3. 下界通配符)

[4. 三种通配符对比](#4. 三种通配符对比)

六、泛型的类型限定

[七、为什么 List 不能赋值给 List](#七、为什么 List 不能赋值给 List)

八、泛型擦除

[1. 不能直接 new T()](#1. 不能直接 new T())

[2. 不能直接创建泛型类型参数数组](#2. 不能直接创建泛型类型参数数组)

[3. 不能通过 instanceof 判断具体泛型参数](#3. 不能通过 instanceof 判断具体泛型参数)

[4. 静态成员不能直接使用类级别的泛型参数](#4. 静态成员不能直接使用类级别的泛型参数)

九、实际开发中使用泛型

十、常用知识点速查


一、泛型

泛型 就是把类型参数化,在定义类、接口或方法时,不提前写死具体的数据类型,而是在使用时指定。

例如,以前创建一个集合:

java 复制代码
ArrayList list = new ArrayList();

list.add("Java");
list.add(123);
list.add(true);

由于没有指定类型,什么数据都可以添加,取出来时还需要类型转换,容易出现 ClassCastException。

使用泛型:

java 复制代码
ArrayList<String> list = new ArrayList<>();

list.add("Java");
list.add("Python");

// list.add(123); // 编译报错

<String> 限定了集合中的元素类型,编译器会帮我们检查。

泛型主要解决三个问题:

  • 类型安全:编译阶段发现类型错误。

  • 减少类型转换:取出数据时不需要频繁强制转换。

  • 提高复用性:一套代码可以适用于不同的数据类型。

二、泛型类

泛型类就是在定义类时声明类型参数。

基本格式:

java 复制代码
public class 类名<T> {
    // T 代表某种类型
}

这里的 T 不是固定的类型,而是一个类型占位符。

例如自己定义一个容器:

java 复制代码
class Box<T> {

    private T data;

    public void setData(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }
}

使用时指定具体类型:

java 复制代码
Box<String> box1 = new Box<>();
box1.setData("Java");

String str = box1.getData();

Box<Integer> box2 = new Box<>();
box2.setData(100);

Integer num = box2.getData();

同一个 Box 类,既能存字符串,也能存整数,不需要为每种类型重新写一个类。

常见泛型标识:

标识 常见含义
T Type,类型
E Element,元素
K Key,键
V Value,值
R Result,结果

这些只是命名习惯,并不是 Java 关键字。

泛型也可以有多个类型参数:

java 复制代码
class Pair<K, V> {

    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
}

使用:

java 复制代码
Pair<String, Integer> pair =
        new Pair<>("age", 25);

三、泛型方法

泛型方法是在方法上单独声明泛型,它不要求所在的类本身是泛型类。

基本格式:

复制代码
修饰符 <T> 返回值类型 方法名(参数列表)

注意:方法自己的 ****要写在返回值类型前面。

例如:

java 复制代码
public class GenericDemo {

    public static <T> void print(T value) {
        System.out.println(value);
    }

    public static void main(String[] args) {
        print("Java");
        print(123);
        print(true);
    }
}

这里 print() 可以接收不同类型的数据,编译器通常会根据传入的参数自动推断类型。

再看一个带返回值的泛型方法:

java 复制代码
public static <T> T getFirst(List<T> list) {
    return list.get(0);
}

调用:

java 复制代码
List<String> names = Arrays.asList("张三", "李四");

String name = getFirst(names);

System.out.println(name); // 张三

这个方法可以适用于 List<String>、List<Integer> 等不同类型的集合。

注意:这里要求列表非空,否则 get(0) 会抛出异常。

泛型类和泛型方法的区别:

对比 泛型类 泛型方法
声明位置 类名后面 方法返回值类型前面
作用范围 类中可以使用 主要在该方法内使用
类型确定 创建或使用对象时 调用方法时通常可以推断
是否依赖泛型类 本身就是泛型类 不需要

还有个容易弄混的地方:泛型类中的普通方法使用类级别的 T,并不代表它自己声明了泛型。

java 复制代码
class Box<T> {

    // 使用类级别的 T
    public void set(T value) {
    }

    // 这是独立的泛型方法
    public <E> void print(E value) {
        System.out.println(value);
    }
}

四、泛型接口

泛型接口和泛型类基本一样,只不过定义在接口上。

java 复制代码
interface Converter<T, R> {
    R convert(T value);
}

这里有两个类型参数:

  • T:输入类型

  • R:返回类型

实现方式一:实现接口时指定具体类型。

java 复制代码
class StringToInteger implements Converter<String, Integer> {

    @Override
    public Integer convert(String value) {
        return Integer.parseInt(value);
    }
}

使用:

java 复制代码
Converter<String, Integer> converter =
        new StringToInteger();

System.out.println(converter.convert("123")); // 123

实现方式二:实现类继续保留泛型。

java 复制代码
class DefaultConverter<T> implements Converter<T, T> {

    @Override
    public T convert(T value) {
        return value;
    }
}

这样实现类依然可以适用于不同的数据类型。

实际开发中,泛型接口非常常见,例如:

java 复制代码
List<String>
Map<String, Integer>
Comparator<User>

其中 List、Map、Comparator 本身都是泛型接口。

五、泛型通配符

这部分比较容易混淆,重点理解三个写法:

  • <?>

  • <? extends T>

  • <? super T>

先看一个问题。

假设有两个集合:

java 复制代码
List<String> names = new ArrayList<>();
List<Integer> numbers = new ArrayList<>();

如果想写一个方法,既可以接收字符串列表,也可以接收整数列表,应该怎么写?

1. 无界通配符 <?>

java 复制代码
public static void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

调用:

java 复制代码
printList(names);
printList(numbers);

<?> 表示元素类型未知,因此可以接收不同元素类型的列表。

但是要注意:

复制代码
List<?> list = new ArrayList<String>();

// list.add("Java"); // 编译报错

因为编译器不知道集合实际允许添加什么类型。

可以读取元素,但通常只能作为 Object 使用;不能直接添加非 null 元素。

2. 上界通配符 <? extends T>

表示元素类型必须是 T 或者 T 的子类型。

例如:

java 复制代码
class Animal {}

class Dog extends Animal {}

class Cat extends Animal {}

定义方法:

java 复制代码
public static void printAnimals(
        List<? extends Animal> animals) {

    for (Animal animal : animals) {
        System.out.println(animal);
    }
}

调用:

java 复制代码
List<Dog> dogs = new ArrayList<>();
List<Cat> cats = new ArrayList<>();

printAnimals(dogs);
printAnimals(cats);

这里可以读取元素并当作 Animal 处理。

但是不能直接添加:

java 复制代码
public static void test(List<? extends Animal> list) {

    // list.add(new Dog()); // 编译报错
}

为什么?

因为传入的可能是 List<Cat>,如果允许添加 Dog,就会破坏集合原来的类型约束。

所以:

**<? extends T>**适合从集合中读取 T 类型的数据。

3. 下界通配符 <? super T>

表示元素类型是 T 或者 T 的父类型。

java 复制代码
public static void addDogs(List<? super Dog> list) {

    list.add(new Dog());
}

可以传入:

java 复制代码
List<Dog> dogs = new ArrayList<>();
List<Animal> animals = new ArrayList<>();
List<Object> objects = new ArrayList<>();

addDogs(dogs);
addDogs(animals);
addDogs(objects);

因为这些集合都可以安全地接收 Dog 对象。

但从这种集合中读取时,编译器只能保证元素是 Object:

复制代码
Object obj = objects.get(0);

**<? super T>**适合向集合中写入 T 类型及其子类型的数据。

4. 三种通配符对比

通配符 含义 读取 添加
<?> 任意未知类型 Object 通常不能
<? extends T> T 或 T 的子类型 可以作为 T 读取 通常不能
<? super T> T 或 T 的父类型 只能保证 Object 可以添加 T 及子类型

这里有个常用原则:PECS。

  • Producer Extends :主要用于提供数据,使用 extends。

  • Consumer Super :主要用于接收数据,使用 super。

也可以直接理解为:主要读数据用 extends,主要写数据用 super。

六、泛型的类型限定

除了通配符,定义泛型时也可以限定类型范围。

例如:

java 复制代码
public static <T extends Number> void printNumber(T value) {
    System.out.println(value);
}

调用:

java 复制代码
printNumber(100);
printNumber(3.14);

// printNumber("Java"); // 编译报错

这里的 <T extends Number> 表示 T 必须是 Number 或其子类。

如果需要多个上界,可以使用 &:

复制代码
<T extends Number & Comparable<T>>

注意:这里的 extends 同样适用于接口约束,不仅仅代表继承类。

另外,泛型类型参数只能使用引用类型,不能使用基本数据类型:

java 复制代码
List<Integer> list = new ArrayList<>();

// List<int> list2; // 编译报错

七、为什么 List<String> 不能赋值给 List<Object>?

这是 Java 泛型比较容易踩坑的地方。

java 复制代码
List<String> names = new ArrayList<>();

// List<Object> objects = names; // 编译报错

虽然 String 是 Object 的子类,但是:

**List**不是 **List**的子类型。

原因也很简单。

假如允许这样赋值:

java 复制代码
List<Object> objects = names;

objects.add(123);

那原本只允许存储字符串的集合,就被添加了整数,类型约束也就失效了。

这种特性叫做泛型的不变性(Invariance)。

如果只是想接收不同类型的集合,可以使用:

复制代码
List<?> list = names;

如果需要读取某个父类型及其子类型的数据,可以使用:

复制代码
List<? extends Object> list = names;

不过这里 List<? extends Object> 与 List<?> 在实际使用上基本等价,通常直接写 List<?> 更简单。

八、泛型擦除

Java 泛型主要在编译阶段起作用。

编译器会进行类型检查,生成字节码时,泛型类型参数通常会被擦除为其上界;没有显式上界的类型参数,通常擦除为 Object。

例如:

java 复制代码
List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();

运行时:

java 复制代码
System.out.println(
        list1.getClass() == list2.getClass()
); // true

因为它们运行时的实际类都是 ArrayList。

这就是 Java 的类型擦除(Type Erasure)。

因此会有一些限制。

1. 不能直接 new T()

java 复制代码
class Box<T> {

    // T obj = new T(); // 编译报错
}

因为运行时无法确定 T 对应的具体类型。

2. 不能直接创建泛型类型参数数组

java 复制代码
class Box<T> {

    // T[] arr = new T[10]; // 编译报错
}

3. 不能通过 instanceof 判断具体泛型参数

java 复制代码
List<String> list = new ArrayList<>();

// list instanceof List<String> // 编译报错

System.out.println(list instanceof List<?>); // true

4. 静态成员不能直接使用类级别的泛型参数

java 复制代码
class Box<T> {

    // private static T data; // 编译报错
}

因为静态成员属于类,而类级别的 T 通常要在具体使用泛型类时才能确定。

如果静态方法需要泛型,可以单独声明:

java 复制代码
public static <T> void print(T value) {
    System.out.println(value);
}

需要补充一点:类型擦除不代表泛型信息完全消失,类或方法声明中的部分泛型信息仍然可以通过反射获取。

九、实际开发中使用泛型

后端开发经常需要返回不同类型的数据。

例如,用户接口返回用户信息,订单接口返回订单信息。

如果每一种数据都定义一个单独的响应类,会产生很多重复代码。

可以使用泛型封装统一响应结果。

java 复制代码
public class Result<T> {

    private int code;
    private String message;
    private T data;

    public Result(int code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }

    public T getData() {
        return data;
    }
}

假设有一个用户类:

java 复制代码
class User {

    private String name;

    public User(String name) {
        this.name = name;
    }
}

返回单个用户:

java 复制代码
Result<User> result =
        new Result<>(200, "success", new User("张三"));

返回用户列表:

java 复制代码
List<User> users = new ArrayList<>();

users.add(new User("张三"));
users.add(new User("李四"));

Result<List<User>> result =
        new Result<>(200, "success", users);

这里的:

java 复制代码
Result<User>
Result<List<User>>

都是在使用同一个泛型类,只是内部的数据类型不同。

十、常用知识点速查

知识点 写法 作用
泛型类 class Box<T> 类级别的类型参数
泛型方法 <T> T get(...) 方法级别的类型参数
泛型接口 interface Converter<T> 接口级别的类型参数
无界通配符 <?> 接收未知元素类型
上界通配符 <? extends T> 接收 T 或子类型,适合读取
下界通配符 <? super T> 接收 T 或父类型,适合写入
类型限定 <T extends Number> 约束泛型类型范围
类型擦除 Type Erasure 泛型的主要运行时实现机制
类型推断 new ArrayList<>() 编译器推断类型参数

重点:

  • T、E、K、V 只是类型参数名称。

  • 泛型类、泛型接口在声明时定义类型参数。

  • 泛型方法需要单独声明自己的类型参数。

  • extends 主要用于安全读取,super 主要用于安全写入。

  • List<String> 不能直接赋值给 List<Object>。

  • Java 泛型采用类型擦除,存在一些运行时限制。

相关推荐
利威尔xu12 分钟前
2026-11-18-Go接口幂等设计实战
开发语言·后端·golang
跳跳的小古风1 小时前
前端转全栈:一条接口从前端请求到 SQL 完整流程
java·前端
eggwyw1 小时前
linux下的C\C++多进程多线程编程实例详解
开发语言·c++
布莱克6052 小时前
Swift 枚举详解:从基础语法到关联值与模式匹配
开发语言·ios·swift·枚举
jianqiang.xue2 小时前
把Agent塞进MCU:工具次数和上下文长度怎么卡
java·前端·网络·单片机·esp32·ai编程
布莱克6052 小时前
Swift 闭包详解:从语法到实战的完整指南
服务器·开发语言·ios·ssh·swift·闭包
努力写代码的熊大3 小时前
Linux 个人复盘博客 · 第六篇 Linux 进程间五种通信:匿名管道、命名管道、共享内存、消息队列与信号量
linux·经验分享·笔记
蒸蒸yyyyzwd3 小时前
深搜广搜学习笔记
笔记·学习
ikgy3 小时前
JAVA EE:4.多线程核心组件实战
java·java-ee