返回专栏
· 13 分钟阅读

子类型与协变、逆变


一、什么是子类型(Subtyping)

子类型(Subtyping)是类型系统中的一种关系,用于描述一个类型能否在另一个类型所要求的位置上安全使用。

如果类型 B 是类型 A 的子类型,通常记作:

B <: A

表示 B 可以在需要 A 的场景中使用。

这里的关键是可替代性,而不仅仅是继承关系。

例如:

class Animal {
    void eat() {}
}

class Dog extends Animal {
    void bark() {}
}

class Cat extends Animal {
    void meow() {}
}

在 Java 中:

  • Dog 是 Animal 的子类型。
  • Cat 是 Animal 的子类型。
  • Animal 是 Dog 的父类型(超类型)。

因此,可以将 Dog 对象赋值给 Animal 类型的变量:

Animal animal = new Dog();

但反过来不成立:

Dog dog = new Animal(); // 编译错误

原因在于:任意 Animal 不一定具备 Dog 的行为。

1. 子类型与继承的区别

继承是实现代码复用和建立类层次结构的一种机制;子类型是类型系统中的兼容性关系。

二者有关联,但不能画等号。

对比维度 继承(Inheritance) 子类型(Subtyping)
所属层面 面向对象实现机制 类型系统关系
核心目的 复用实现、扩展行为 保证类型可替代性
是否必须有继承关系 是,针对类继承 不一定
是否涉及类型兼容 通常涉及 核心就是类型兼容
典型例子 Java extends Go 接口、TypeScript 结构化类型

例如 Go:

type Animal interface {
    Eat()
}

type Dog struct{}

func (Dog) Eat() {}

Dog 没有显式继承 Animal,但由于实现了接口要求的方法,因此可以满足 Animal 类型约束。

TypeScript 也采用结构化类型兼容规则:

type Animal = {
    eat(): void;
};

type Dog = {
    eat(): void;
    bark(): void;
};

const dog: Dog = {
    eat() {},
    bark() {}
};

const animal: Animal = dog;

Dog 具有 Animal 所要求的结构,因此可以赋值给 Animal。

2. 子类型与里氏替换原则

子类型关系与里氏替换原则(Liskov Substitution Principle,LSP)密切相关。

里氏替换原则强调:

如果 B 是 A 的子类型,那么在使用 A 的地方,应该能够安全地使用 B,而不破坏程序原有的正确性。

这不仅要求方法名称相同,还要求行为契约兼容。

例如:

class Bird {
    void eat() {}
}

class Sparrow extends Bird {
    void fly() {}
}

Sparrow 可以作为 Bird 使用,因为它保留了 Bird 的基本行为。

但如果设计成:

class Bird {
    void fly() {}
}

class Penguin extends Bird {
    @Override
    void fly() {
        throw new UnsupportedOperationException();
    }
}

企鹅虽然继承了 Bird,但无法正常履行 fly() 的行为契约。

这说明继承关系不一定意味着合理的子类型关系。

子类型需要满足行为上的可替代性,而不只是语法上的继承关系。

二、什么是型变(Variance)

型变(Variance)描述的是:当类型参数之间存在子类型关系时,泛型类型之间是否也存在相应的子类型关系,以及这种关系的方向是什么。

假设:

Dog <: Animal

对于泛型类型 Container<T>,需要回答:

  • Container<Dog> 是否是 Container<Animal> 的子类型?
  • 如果是,关系方向是否与类型参数一致?
  • 是否应该反过来?
  • 是否两者都不兼容?

根据答案,型变分为三种:

类型 英文 类型参数关系 泛型关系
协变 Covariance 同方向 同方向
逆变 Contravariance 反方向 反方向
不变 Invariance 不建立子类型关系 不建立子类型关系

假设:

Dog <: Animal

那么:

协变:

Dog <: Animal
Container<Dog> <: Container<Animal>

逆变:

Dog <: Animal
Consumer<Animal> <: Consumer<Dog>

不变:

Container<Dog> \not<: Container<Animal>

同时:

Container<Animal> \not<: Container<Dog>

这里的关键不是泛型类型名称,而是泛型类型参数在类型定义中的使用方式。

三、协变(Covariance)

协变表示:当类型参数从父类型变成子类型时,泛型整体也保持相同方向的子类型关系。

如果:

Dog <: Animal

那么协变容器满足:

Container<Dog> <: Container<Animal>

也就是说,装有 Dog 的容器可以在需要 Animal 容器的地方使用。

1. 协变的直观理解

假设有一个只负责读取动物的接口:

interface Producer<T> {
    T get();
}

Producer<Dog> 只会产生 Dog,而 Dog 本身就是 Animal。

因此,调用方完全可以把它当成 Producer<Animal> 使用。

例如:

Producer<Dog> dogProducer = ...;
Producer<? extends Animal> animalProducer = dogProducer;

Animal animal = animalProducer.get();

这里的 ? extends Animal 表示类型参数是 Animal 或其某个子类型。

调用方可以安全地读取一个 Animal,因为实际返回的对象一定是 Animal 的子类型。

2. 为什么协变适合生产者

生产者(Producer)只向外提供数据。

假设:

interface Producer<T> {
    T get();
}

当 T 是 Dog 时:

  • get() 返回 Dog。
  • Dog 一定可以赋值给 Animal。
  • 调用方只要求得到一个 Animal,并不关心它是不是更具体的 Dog。

因此,协变适合只输出类型参数的场景。

3. Java 中的协变

Java 泛型默认是不变的,但可以通过通配符 ? extends 实现使用位置上的协变。

class Animal {}

class Dog extends Animal {}

class Cat extends Animal {}

static void printAnimals(List<? extends Animal> animals) {
    for (Animal animal : animals) {
        System.out.println(animal);
    }
}

以下调用都可以通过编译:

List<Dog> dogs = new ArrayList<>();
List<Cat> cats = new ArrayList<>();

printAnimals(dogs);
printAnimals(cats);

因为 List<? extends Animal> 可以接收类型参数为 Animal 或其子类型的列表。

4. 协变的写入限制

协变容器有一个重要限制:不能安全地向其中写入具体的子类型对象。

List<? extends Animal> animals = new ArrayList<Dog>();

animals.add(new Dog()); // 编译错误
animals.add(new Cat()); // 编译错误

为什么?

因为编译器无法确定 animals 的实际元素类型究竟是:

  • List<Dog>
  • List<Cat>
  • List<Animal>

如果允许写入 Cat,而实际对象是 List<Dog>,就会破坏类型安全。

不过,可以写入 null,因为 null 可以赋值给引用类型。

协变容器的核心规则:

  • 可以读取为父类型。
  • 不能写入具体的非空元素。
  • 适合数据生产和只读访问。

注意,Java 的 List<? extends Animal> 并不意味着底层列表真的不可修改。它限制的是通过当前引用进行的类型安全写入,而不是让对象本身变成不可变集合。

四、逆变(Contravariance)

逆变表示:当类型参数从父类型变成子类型时,泛型整体的子类型关系反向变化。

如果:

Dog <: Animal

那么逆变关系满足:

Consumer<Animal> <: Consumer<Dog>

也就是说,能够处理任意 Animal 的消费者,也一定能够处理 Dog。

1. 逆变的直观理解

假设有一个只负责消费动物的接口:

interface Consumer<T> {
    void accept(T value);
}

现在有两个消费者:

  • Consumer<Animal>:可以接收任意动物。
  • Consumer<Dog>:只能接收狗。

如果调用方只会传入 Dog,那么一个能够接收所有 Animal 的消费者显然也能处理 Dog。

因此:

Consumer<Animal> <: Consumer<Dog>

方向与原始类型的子类型关系相反。

2. 为什么逆变适合消费者

消费者(Consumer)只接收数据,不向外返回类型参数。

interface Consumer<T> {
    void accept(T value);
}

如果 T 是 Animal,那么它可以接受:

  • Dog
  • Cat
  • 其他 Animal 子类型

所以,只要调用方提供的是 Dog,一个接受 Animal 的消费者就足够了。

逆变适合参数输入、事件处理、回调函数和比较器等场景。

3. Java 中的逆变

Java 可以使用 ? super 表达使用位置上的逆变。

class Animal {}

class Dog extends Animal {}

static void addDog(List<? super Dog> animals) {
    animals.add(new Dog());
}

以下类型都可以传入:

List<Dog> dogs = new ArrayList<>();
List<Animal> animals = new ArrayList<>();
List<Object> objects = new ArrayList<>();

addDog(dogs);
addDog(animals);
addDog(objects);

因为这些列表的元素类型都是 Dog 或 Dog 的父类型。

4. 逆变的读取限制

List<? super Dog> animals = new ArrayList<Animal>();

animals.add(new Dog()); // 合法

Dog dog = animals.get(0); // 编译错误
Object value = animals.get(0); // 合法

为什么读取只能安全地得到 Object?

因为 animals 可能实际是:

  • List<Dog>
  • List<Animal>
  • List<Object>

从中取出的元素可能是 Dog,也可能是其他 Animal,甚至是其他对象。

因此,编译器只能保证读取结果至少是 Object。

逆变容器的核心规则:

  • 可以写入指定子类型。
  • 读取时通常只能安全地得到 Object。
  • 适合数据消费和参数输入。

五、不变(Invariance)

不变表示:即使类型参数之间存在子类型关系,泛型整体也不建立对应的子类型关系。

如果:

Dog <: Animal

那么:

Container<Dog> \not<: Container<Animal>

并且:

Container<Animal> \not<: Container<Dog>

1. 为什么需要不变

假设允许:

List<Dog> dogs = new ArrayList<>();
List<Animal> animals = dogs;

那么就可以通过 animals 向列表中添加 Cat:

animals.add(new Cat());

此时原本声明为 List<Dog> 的集合中出现了 Cat。

后续代码:

Dog dog = dogs.get(0);

就可能在运行时出现类型错误。

因此,如果一个泛型容器同时允许读取和写入类型参数,不进行额外约束时,通常需要保持不变。

2. Java 泛型默认不变

Java 泛型默认采用不变规则。

List<Dog> dogs = new ArrayList<>();

List<Animal> animals = dogs; // 编译错误

虽然 Dog 是 Animal 的子类型,但 List<Dog> 并不是 List<Animal> 的子类型。

这是 Java 泛型类型安全设计的重要组成部分。

3. 不变不代表不能读取和写入

不变只是表示两个不同类型参数的泛型实例之间没有子类型兼容关系。

对于明确的 List<Dog>,仍然可以正常读取和写入 Dog:

List<Dog> dogs = new ArrayList<>();

dogs.add(new Dog());

Dog dog = dogs.get(0);

不变限制的是不同泛型实例之间的类型替代关系,而不是容器自身的操作能力。

六、协变、逆变与不变的对比

假设:

Dog <: Animal

三种型变的区别如下:

型变类型 泛型关系 主要用途 典型方向
协变 Producer<Dog> 可替代 Producer<Animal> 生产数据 输出
逆变 Consumer<Animal> 可替代 Consumer<Dog> 消费数据 输入
不变 两者不能相互替代 同时读写 输入与输出

可以用一个简单原则理解:

  • 协变:输出更具体的类型,能够满足需要更一般类型的调用方。
  • 逆变:输入更一般的类型,能够处理调用方提供的更具体类型。
  • 不变:输入和输出相互影响,不能随意改变类型参数的兼容方向。

七、函数类型中的协变与逆变

协变和逆变不仅存在于泛型容器,也存在于函数类型中。

函数类型可以表示为:

A \rightarrow B

其中:

  • A 是参数类型。
  • B 是返回值类型。

对于函数类型,通常遵循:

  • 返回值类型协变。
  • 参数类型逆变。

这是型变中非常重要、也最容易混淆的部分。

1. 返回值协变

假设:

Dog <: Animal

现在有两个函数:

f1: () -> Dog
f2: () -> Animal

f1 返回 Dog,而 Dog 可以作为 Animal 使用。

因此,任何需要返回 Animal 的调用方,都可以使用返回 Dog 的函数。

所以:

() \rightarrow Dog <: () \rightarrow Animal

返回值允许从父类型收窄到子类型,这就是返回值协变。

2. 参数类型逆变

假设:

Dog <: Animal

有两个函数:

f1: Animal -> void
f2: Dog -> void

f1 可以接收任何 Animal,当然也能接收 Dog。

而 f2 只能接收 Dog。

如果调用方需要一个能够处理任意 Animal 的函数,就不能随便传入只能处理 Dog 的函数。

但如果调用方只会传入 Dog,那么 f1 完全可以胜任。

因此:

(Animal \rightarrow void) <: (Dog \rightarrow void)

参数类型的兼容方向与子类型关系相反,这就是参数逆变。

3. 函数型变的完整关系

假设:

Dog <: Animal

那么:

Dog \rightarrow Dog <: Animal \rightarrow Animal

这里:

  • 输入参数从 Animal 变为 Dog,属于逆变方向。
  • 返回值从 Dog 变为 Animal,属于协变方向。

函数类型的完整规则可以表示为:

(S_1 \rightarrow T_1) <: (S_2 \rightarrow T_2)

当满足:

S_2 <: S_1

并且:

T_1 <: T_2

时,函数类型才具有对应的子类型关系。

也就是:

  • 参数类型反向兼容。
  • 返回值类型同向兼容。

4. 函数型变的示例

TypeScript:

class Animal {}

class Dog extends Animal {}

type AnimalHandler = (value: Animal) => void;
type DogHandler = (value: Dog) => void;

const handleAnimal: AnimalHandler = (value) => {
    console.log(value);
};

const handleDog: DogHandler = handleAnimal;

handleAnimal 可以处理所有动物,因此也能处理 Dog。

但反过来:

const handleAnimal2: AnimalHandler = handleDog;

在严格函数类型检查下,这种赋值通常不成立,因为 handleDog 无法保证处理任意 Animal。

注意:TypeScript 的方法参数与函数属性参数在兼容性检查上存在历史设计差异,方法声明可能采用更宽松的双变规则。分析代码时应结合 strictFunctionTypes 和具体声明形式判断。

八、为什么输入逆变、输出协变

这可以从类型安全的角度推导。

假设一个函数需要满足以下契约:

输入:Animal
输出:Animal

调用方可能传入任意 Animal,并期望得到一个 Animal。

现在考虑替换为另一个函数:

输入:Dog
输出:Dog

它存在两个问题:

  1. 它只能接收 Dog,无法处理 Cat。
  2. 它虽然返回 Dog,但这部分没有问题,因为 Dog 可以作为 Animal 使用。