Kotlin 中的协变与逆变

在 Kotlin 中，协变（covariance）和逆变（contravariance）是与类型参数相关的重要概念。它们允许我们在泛型类型的继承关系中更灵活地处理类型转换。本文将介绍协变和逆变的概念，并通过示例代码来说明它们的用法和好处。

协变（Covariance）

协变是指在类型参数的继承关系中，允许将一个泛型类型的子类型赋值给父类型。在 Kotlin 中，我们可以使用 out 关键字来标记类型参数为协变。这样一来，我们就可以安全地将一个泛型类型的子类型赋值给父类型。

下面是一个示例，展示了如何在 Kotlin 中使用协变：

class Animal
class Cat : Animal()

interface Container<out T> {
    fun getItem(): T
}

fun main() {
    val catContainer: Container<Cat> = object : Container<Cat> {
        override fun getItem(): Cat {
            return Cat()
        }
    }

    val animalContainer: Container<Animal> = catContainer // 协变

    val animal: Animal = animalContainer.getItem()
    println(animal)
}

在上面的代码中，我们定义了一个 Container 接口，它具有一个协变类型参数 T。我们创建了一个 catContainer 对象，它的类型是 Container。然后，我们将 catContainer 赋值给 animalContainer，因为 Container 是协变的，所以这个赋值是合法的。最后，我们通过 animalContainer 获取了一个 Animal 对象。

逆变（Contravariance）

逆变是指在类型参数的继承关系中，允许将一个泛型类型的父类型赋值给子类型。在 Kotlin 中，我们可以使用 in 关键字来标记类型参数为逆变。这样一来，我们就可以安全地将一个泛型类型的父类型赋值给子类型。

下面是一个示例，展示了如何在 Kotlin 中使用逆变：

class Animal
class Cat : Animal()

interface Processor<in T> {
    fun process(item: T)
}

fun main() {
    val animalProcessor: Processor<Animal> = object : Processor<Animal> {
        override fun process(item: Animal) {
            println("Processing animal: $item")
        }
    }

    val catProcessor: Processor<Cat> = animalProcessor // 逆变

    catProcessor.process(Cat())
}

在上面的代码中，我们定义了一个 Processor 接口，它具有一个逆变类型参数 T。我们创建了一个 animalProcessor 对象，它的类型是 Processor。然后，我们将 animalProcessor 赋值给 catProcessor，因为 Processor 是逆变的，所以这个赋值是合法的。最后，我们使用 catProcessor 处理了一个 Cat 对象。

总结

协变和逆变是 Kotlin 泛型中非常有用的特性，它们使得类型之间的转换更加灵活和安全。通过使用 out 和 in 关键字，我们可以轻松地声明协变和逆变的类型参数，并在继承关系中进行类型赋值。使用这些特性，我们可以编写更具扩展性和可复用性的代码。