Java 协变与逆变深入解析

简介

在 Java 编程中，协变（Covariance）和逆变（Contravariance）是两个重要的概念，它们主要涉及到泛型类型的兼容性问题。理解和掌握这两个概念有助于我们编写更加灵活和安全的代码。本文将详细介绍 Java 中协变和逆变的基础概念、使用方法、常见实践以及最佳实践。

基础概念

协变

协变是指允许类型的层次结构在赋值或传递时保持一致的方向。简单来说，如果 B 是 A 的子类型，那么 List<B> 可以被视为 List<? extends A> 的子类型。协变允许我们从泛型类型中安全地读取元素，但不允许写入元素。

逆变

逆变则是指类型的层次结构在赋值或传递时方向相反。如果 B 是 A 的子类型，那么 List<? super B> 可以被视为 List<? super A> 的子类型。逆变允许我们向泛型类型中安全地写入元素，但读取元素时只能得到 Object 类型。

使用方法

协变的使用

协变通常使用 ? extends 通配符来实现。以下是一个简单的示例：

import java.util.ArrayList;
import java.util.List;

class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

public class CovarianceExample {
    public static void main(String[] args) {
        List<Dog> dogList = new ArrayList<>();
        dogList.add(new Dog());

        // 使用协变
        List<? extends Animal> animalList = dogList;
        for (Animal animal : animalList) {
            animal.eat();
        }

        // 以下代码会编译错误，因为协变不允许写入元素
        // animalList.add(new Dog());
    }
}

在上述代码中，List<Dog> 可以赋值给 List<? extends Animal>，我们可以安全地从 animalList 中读取元素，但不能向其中写入元素。

逆变的使用

逆变使用 ? super 通配符来实现。以下是一个示例：

import java.util.ArrayList;
import java.util.List;

class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

public class ContravarianceExample {
    public static void main(String[] args) {
        List<Animal> animalList = new ArrayList<>();

        // 使用逆变
        List<? super Dog> dogSuperList = animalList;
        dogSuperList.add(new Dog());

        // 读取元素时只能得到 Object 类型
        for (Object obj : dogSuperList) {
            if (obj instanceof Dog) {
                ((Dog) obj).eat();
            }
        }
    }
}

在上述代码中，List<Animal> 可以赋值给 List<? super Dog>，我们可以安全地向 dogSuperList 中写入 Dog 类型的元素，但读取元素时只能得到 Object 类型。

常见实践

协变在集合中的应用

协变在集合中经常用于安全地遍历元素。例如，我们可以编写一个方法来处理任何 List 中的 Animal 元素：

import java.util.List;

class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

public class CovarianceInCollection {
    public static void printAnimals(List<? extends Animal> animalList) {
        for (Animal animal : animalList) {
            animal.eat();
        }
    }

    public static void main(String[] args) {
        List<Dog> dogList = List.of(new Dog());
        printAnimals(dogList);
    }
}

在上述代码中，printAnimals 方法可以接受任何 List 类型的 Animal 子类型，这样我们就可以安全地遍历其中的元素。

逆变在方法参数中的应用

逆变在方法参数中常用于需要写入元素的场景。例如，我们可以编写一个方法来向 List 中添加 Dog 元素：

import java.util.List;

class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

public class ContravarianceInMethod {
    public static void addDogs(List<? super Dog> dogList) {
        dogList.add(new Dog());
    }

    public static void main(String[] args) {
        List<Animal> animalList = java.util.Collections.emptyList();
        addDogs(animalList);
    }
}

在上述代码中，addDogs 方法可以接受任何 List 类型的 Dog 父类型，这样我们就可以安全地向其中添加 Dog 元素。

最佳实践

协变与逆变的选择

在选择使用协变还是逆变时，我们可以遵循 PECS 原则（Producer Extends, Consumer Super）。如果泛型类型主要用于生产元素（即读取元素），则使用 ? extends 通配符；如果泛型类型主要用于消费元素（即写入元素），则使用 ? super 通配符。

避免潜在的类型安全问题

虽然协变和逆变可以提高代码的灵活性，但也可能引入类型安全问题。在使用协变和逆变时，我们应该明确知道自己在做什么，避免在不恰当的地方进行元素的读写操作。

小结

本文详细介绍了 Java 中协变和逆变的基础概念、使用方法、常见实践以及最佳实践。协变使用 ? extends 通配符，允许安全地读取元素；逆变使用 ? super 通配符，允许安全地写入元素。在实际编程中，我们可以根据 PECS 原则来选择使用协变还是逆变，并注意避免潜在的类型安全问题。

参考资料

《Effective Java》
Java 官方文档