返回专栏
· 13 分钟阅读

泛型与参数化多态


一、什么是泛型(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)

泛型类型参数之间存在子类型关系,并不意味着泛型整体一定具有相同的子类型关系。

假设:

Dog <: Animal

不能直接推导:

List<Dog> <: List<Animal>

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 通配符的实用原则,但它不是所有语言通用的型变语法规则。

六、泛型的实现机制

泛型的语法相似,但不同语言在编译器和运行时层面的实现差异很大。

主要有三种实现思路:

  1. 类型擦除(Type Erasure)。
  2. 单态化(Monomorphization)。
  3. 运行时保留泛型类型信息。

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#
类型检查 编译期 编译期 编译期与运行时机制配合
类型参数运行时信息 普通类型参数通常擦除 通常通过具体实例体现 可以保留构造泛型类型信息
代码生成 通用擦除后实现 按具体类型实例化 由运行时实现决定
运行时分派开销 通常不因泛型本身增加 通常不需要泛型动态分派 视具体实现而定
代码体积 通常较小 可能增加 取决于运行时策略