一、什么是泛型(Generics)
泛型(Generics)是一种允许程序在定义函数、类、接口和数据结构时使用类型参数的机制。
传统代码通常需要为不同类型编写重复实现:
class IntBox {
private int value;
public void set(int value) {
this.value = value;
}
public int get() {
return value;
}
}
class StringBox {
private String value;
public void set(String value) {
this.value = value;
}
public String get() {
return value;
}
}
这两个类的业务逻辑几乎相同,区别只是存储的数据类型。
泛型可以将类型抽象为参数:
class Box<T> {
private T value;
public void set(T value) {
this.value = value;
}
public T get() {
return value;
}
}
使用时指定具体类型:
Box<Integer> intBox = new Box<>();
intBox.set(100);
Box<String> stringBox = new Box<>();
stringBox.set("hello");
其中:
T是类型参数(Type Parameter)。Integer、String是类型实参(Type Argument)。Box<T>是泛型类型。Box<Integer>和Box<String>是参数化类型。
泛型的核心不是简单地复用代码,而是让代码在保留类型信息和类型约束的前提下实现复用。
二、参数化多态(Parametric Polymorphism)
参数化多态(Parametric Polymorphism)是一种多态机制,允许程序使用类型参数描述一类类型,并通过替换类型参数得到适用于不同类型的实现。
例如:
public static <T> T identity(T value) {
return value;
}
这个函数不关心参数究竟是 String、Integer 还是其他类型,只要求输入和输出保持相同的类型关系。
调用:
String name = identity("Alice");
Integer age = identity(18);
Double score = identity(99.5);
同一个函数可以应用于多种类型。
1. 参数化多态的核心特征
类型参数化
使用类型变量表示尚未确定的类型。
统一实现
不同类型共享同一套算法逻辑,而不是为每种类型复制一份实现。
类型关系保持
类型参数在输入、输出和数据结构中的关系由类型系统约束。
类型安全
在静态类型语言中,编译器可以检查类型参数的使用是否合法。
2. 泛型与参数化多态的关系
两者密切相关,但概念层次不同。
| 概念 | 关注点 | 示例 |
|---|---|---|
| 泛型(Generics) | 语言提供的类型参数机制 | List<T> |
| 参数化多态 | 类型参数带来的多态能力 | identity<T>(T) |
| 类型参数 | 定义中的类型变量 | T |
| 类型实参 | 使用时提供的具体类型 | String |
| 参数化类型 | 类型参数替换后的类型 | List<String> |
泛型通常是参数化多态在编程语言中的一种重要实现形式。
不过,不同语言的泛型实现并不完全相同。有些语言支持完整的参数化多态,有些语言则通过类型擦除、单态化或其他编译机制实现类似能力。
三、泛型的基本组成
1. 类型参数(Type Parameter)
类型参数是在定义泛型时使用的占位类型。
常见命名约定:
| 名称 | 常见含义 |
|---|---|
T |
Type,通用类型 |
E |
Element,集合元素 |
K |
Key,键类型 |
V |
Value,值类型 |
N |
Number,数值类型 |
R |
Return,返回类型 |
S、U |
其他类型参数 |
这些只是命名习惯,不是语言强制规定。
例如:
class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
}
这里有两个独立的类型参数:
K描述键的类型。V描述值的类型。
2. 类型实参(Type Argument)
类型实参是在使用泛型时提供的具体类型。
Pair<String, Integer> pair =
new Pair<>("age", 18);
对应关系:
| 类型参数 | 类型实参 |
|---|---|
K |
String |
V |
Integer |
类型参数属于泛型定义,类型实参属于泛型使用。
3. 泛型方法
泛型不仅可以用于类,也可以用于独立方法。
public static <T> void print(T value) {
System.out.println(value);
}
这里的 <T> 声明了方法自己的类型参数。
泛型方法的类型参数与类的类型参数是两个不同层次。
class Processor<T> {
public T process(T value) {
return value;
}
public <R> R convert(T value, Function<T, R> converter) {
return converter.apply(value);
}
}
其中:
T是类级别类型参数。R是方法级别类型参数。
方法级别的 R 可以与类级别的 T 独立推断。
4. 泛型接口
interface Repository<T, ID> {
T findById(ID id);
void save(T entity);
void deleteById(ID id);
}
实现时可以指定具体类型:
class UserRepository implements Repository<User, Long> {
@Override
public User findById(Long id) {
return null;
}
@Override
public void save(User user) {}
@Override
public void deleteById(Long id) {}
}
泛型接口适合定义通用能力,将具体数据类型交给实现类决定。
四、泛型的类型约束(Type Constraints)
泛型并不意味着类型参数可以任意使用。
类型参数可以参与哪些操作,取决于它满足的约束。
例如:
public static <T> T max(T a, T b) {
return a > b ? a : b;
}
这段 Java 代码无法编译,因为编译器不知道任意 T 是否支持大于比较。
需要对类型参数增加约束。
1. 上界约束(Upper Bounds)
Java 可以使用 extends 指定类型参数的上界:
public static <T extends Number> double sum(T a, T b) {
return a.doubleValue() + b.doubleValue();
}
这里要求 T 必须是 Number 或其子类型。
因此,可以调用:
sum(10, 20);
sum(10.5, 20.5);
但不能传入不满足约束的类型:
sum("10", "20"); // 编译错误
上界约束的作用是缩小类型参数的合法范围,让编译器能够确定类型具备哪些能力。
2. 多重上界约束
Java 支持多个上界:
public static <T extends Number & Comparable<T>>
T max(T a, T b) {
return a.compareTo(b) >= 0 ? a : b;
}
这里要求 T 同时满足:
- 是
Number的子类型。 - 实现
Comparable<T>。
注意,Java 多重上界中,类类型必须放在最前面,后面可以跟接口类型。
3. 下界约束(Lower Bounds)
Java 的通配符支持下界:
List<? super Integer>
表示列表元素类型是 Integer 或其父类型。
例如:
List<Integer> integers = new ArrayList<>();
List<Number> numbers = new ArrayList<>();
List<Object> objects = new ArrayList<>();
List<? super Integer> a = integers;
List<? super Integer> b = numbers;
List<? super Integer> c = objects;
需要区分:
<T extends Number>是类型参数上界。? extends Number是通配符上界。? super Integer是通配符下界。
Java 的泛型方法可以声明类型参数上界,但不能直接声明类似 <T super Integer> 的类型参数下界。
4. 约束的本质
泛型约束的本质是限制类型参数的可用操作。
flowchart TD
A["声明泛型类型参数 T"] --> B["是否存在类型约束"]
B -->|"没有"| C["只能使用 T 可确定的通用能力"]
B -->|"有"| D["检查类型参数是否满足约束"]
D --> E{"是否满足约束"}
E -->|"是"| F["允许使用约束提供的能力"]
E -->|"否"| G["类型检查失败"]
F --> H["生成或检查泛型实现"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
style C fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#FBE9E9,stroke:#D9AAAA,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
五、泛型与型变(Variance)
泛型类型参数之间存在子类型关系,并不意味着泛型整体一定具有相同的子类型关系。
假设:
不能直接推导:
Java 的泛型默认是不变的。
1. 协变(Covariance)
协变表示类型参数的子类型关系与泛型整体的子类型关系方向一致。
List<? extends Animal>
允许接收:
List<Dog>
List<Cat>
List<Animal>
适合读取数据的生产者场景。
2. 逆变(Contravariance)
逆变表示泛型整体的子类型关系与类型参数的子类型关系方向相反。
List<? super Dog>
允许接收:
List<Dog>
List<Animal>
List<Object>
适合写入数据的消费者场景。
3. 不变(Invariance)
泛型整体不建立类型参数之间的子类型兼容关系。
Java 的 List<T> 就是不变的。
4. PECS 原则
Java 泛型设计中常用 PECS 原则:
- Producer Extends:生产者使用
extends。 - Consumer Super:消费者使用
super。
public static void copy(
List<? extends Animal> source,
List<? super Animal> target
) {
for (Animal animal : source) {
target.add(animal);
}
}
这里:
source负责提供Animal。target负责接收Animal。
PECS 是理解 Java 通配符的实用原则,但它不是所有语言通用的型变语法规则。
六、泛型的实现机制
泛型的语法相似,但不同语言在编译器和运行时层面的实现差异很大。
主要有三种实现思路:
- 类型擦除(Type Erasure)。
- 单态化(Monomorphization)。
- 运行时保留泛型类型信息。
1. 类型擦除(Type Erasure)
Java 泛型主要采用类型擦除机制。
编译器在编译阶段检查泛型类型约束,并在生成字节码时擦除大部分泛型类型参数信息。
例如:
List<String> names = new ArrayList<>();
names.add("Alice");
String name = names.get(0);
编译后的字节码层面,集合主要使用普通的 List 类型,并在需要时插入类型转换。
可以将其简化理解为:
List names = new ArrayList();
names.add("Alice");
String name = (String) names.get(0);
这只是帮助理解的近似示意,不是完整的真实编译结果。
类型擦除带来几个重要特点:
- 泛型类型检查主要发生在编译期。
- 普通泛型类型参数通常不会作为独立运行时类型保留。
- 泛型集合在运行时通常无法直接区分
List<String>和List<Integer>。 - 编译器可能插入类型转换。
- 编译器可能生成桥接方法(Bridge Method),维持泛型覆盖和多态行为。
例如:
List<String> strings = new ArrayList<>();
List<Integer> integers = new ArrayList<>();
System.out.println(strings.getClass() == integers.getClass());
// true
这里比较的是运行时集合对象的实际类,而不是编译期的完整参数化类型。
注意:Java 并不是完全丢弃所有泛型相关信息。类文件中的 Signature 等元数据可以保留部分泛型声明信息,供编译器、反射和工具使用,但这不等于普通泛型参数都能在运行时完整参与类型检查。
2. 单态化(Monomorphization)
Rust 使用单态化实现泛型。
编译器根据实际使用的类型参数,为不同类型生成对应的具体实现。
例如:
fn identity<T>(value: T) -> T {
value
}
fn main() {
let a = identity(10);
let b = identity("hello");
}
编译器可以针对不同类型生成专门的机器代码实例。
概念上可以理解为:
fn identity_i32(value: i32) -> i32 {
value
}
fn identity_str(value: &str) -> &str {
value
}
这只是说明单态化结果的示意代码,并非编译器实际生成的函数命名。
单态化的特点:
- 泛型实现可以针对具体类型生成专门代码。
- 运行时通常不需要额外的泛型类型分派。
- 有利于编译器进行内联和优化。
- 不同类型实例可能增加最终二进制体积。
- 编译时间可能随泛型实例数量增加。
C++ 模板也采用类似的实例化思想,但其模板系统与 Rust 泛型的约束和语义并不相同。
3. 运行时保留泛型信息
某些语言或运行时会保留更多泛型类型信息。
例如 C# 的 CLR 泛型支持运行时泛型类型信息,并且运行时可以区分不同的构造泛型类型。
List<string> names = new List<string>();
List<int> numbers = new List<int>();
Console.WriteLine(names.GetType());
Console.WriteLine(numbers.GetType());
CLR 可以在运行时识别这些不同的构造泛型类型。
不过,具体机器代码是否为每个类型都生成独立副本,还取决于运行时实现和类型参数情况。不能简单地认为 C# 一定为每个泛型类型生成完全独立的机器代码。
4. 三种实现机制对比
| 对比维度 | 类型擦除 | 单态化 | 运行时保留泛型信息 |
|---|---|---|---|
| 代表语言 | Java | Rust、C++ 模板 | C# |
| 类型检查 | 编译期 | 编译期 | 编译期与运行时机制配合 |
| 类型参数运行时信息 | 普通类型参数通常擦除 | 通常通过具体实例体现 | 可以保留构造泛型类型信息 |
| 代码生成 | 通用擦除后实现 | 按具体类型实例化 | 由运行时实现决定 |
| 运行时分派开销 | 通常不因泛型本身增加 | 通常不需要泛型动态分派 | 视具体实现而定 |
| 代码体积 | 通常较小 | 可能增加 | 取决于运行时策略 |