写了这么久 Kotlin，你真的理解 in、out 和 * 吗？

各位 Kotlin 爱好者们，早上好。

今天我们深入研究一下 Kotlin 泛型。

跟其他语言一样，Kotlin 通过泛型来处理不同的类型。你可以定义适用于不同类型的类、方法和属性，让代码更容易复用，同时保留类型安全。

我们可以把泛型理解成一个能装不同东西的盒子：水果、玩具、书都能装，不需要为每种东西单独设计一个盒子。泛型容器和函数也是如此，它们能处理不同类型的数据，还能在程序运行前帮你发现类型错误。

这篇文章从简单例子开始，逐步介绍 Kotlin 开发者需要了解的泛型基础。

各代码块按独立示例阅读，重复的类名、函数名和 main 不需要合并到同一个文件；健康动物示例会复用前一个示例中的 Animal。

什么是泛型

泛型允许类、接口、方法和属性使用稍后才确定的类型。需要处理多种数据类型，又希望保留类型安全时，就可以用它。

例如：你需要一个容器，能存放整数、字符串或自定义对象。与其为每种类型写一个类，不如用泛型定义一个可复用的容器类。

在 Kotlin 中，同一个泛型类、方法或属性可以处理不同类型的数据，减少重复代码。

基本语法

Kotlin 泛型类和泛型函数的基本写法如下：

class Box<T>(val content: T)

fun <T> printContent(content: T) {
    println(content)
}

这里的 T 是类型参数，使用类或函数时，可以用具体类型替换它。

下面定义一个简单的泛型类 Box：

class Box<T>(val value: T) {
    fun getContent(): T {
        return value
    }
}

fun main() {
    val intBox = Box(10)
    val stringBox = Box("Hello")
    println(intBox.getContent()) // Output: 10
    println(stringBox.getContent()) // Output: Hello
}

这个 Box 可以存放整数、字符串，也可以存放其他类型的内容。同一份类定义可以用于不同数据类型。

例如，购物车系统可以用这样的 Box 存放不同类型的商品，包括电子产品、书籍和食品。

泛型的好处

类型安全：编译器会检查类型，降低运行时出现 ClassCastException 的风险。

代码复用：用同一个类或函数处理不同类型，不需要重复实现。

类型转换与性能：泛型可以减少调用方手写的类型转换，但不能据此保证性能更好。JVM 泛型存在类型擦除，编译器仍可能插入类型转换，基本类型还可能涉及装箱。

可读性：相比直接使用 Any，泛型能更清楚地表达类型之间的关系和代码意图。

泛型函数

泛型也可以用于函数，让同一个函数处理不同类型的数据。

例如：你需要打印任意列表中的元素。整数列表、字符串列表等都可以交给同一个泛型函数，不必分别实现。

fun <T> printList(items: List<T>) {
    for (item in items) {
        println(item)
    }
}

fun main() {
    val intList = listOf(1, 2, 3)
    val stringList = listOf("a", "b", "c")
    
    println("Printing integer list:")
    printList(intList) // Output: 1, 2, 3
    
    println("Printing string list:")
    printList(stringList) // Output: a, b, c
    
    // Works with custom types too
    data class User(val id: Int, val name: String)
    val userList = listOf(
        User(1, "Alice"),
        User(2, "Bob"),
        User(3, "Charlie")
    )
    
    println("Printing user list:")
    printList(userList) // Output: User(id=1, name=Alice), User(id=2, name=Bob), User(id=3, name=Charlie)
}

printList 可以接收不同元素类型的列表并打印内容，包括自定义类型的列表。

进阶用法

泛型函数还可以实现转换和筛选等操作：

// Transform a list of one type to another type
fun <T, R> List<T>.transformList(transform: (T) -> R): List<R> {
    return this.map { transform(it) }
}

// Find elements in a list that match a condition
fun <T> List<T>.findElements(predicate: (T) -> Boolean): List<T> {
    return this.filter { predicate(it) }
}

fun main() {
    val numberList = listOf(1, 2, 3, 4, 5)
    
    // Square each number
    val squaredNumbers = numberList.transformList { it * it }
    println("Squared numbers: $squaredNumbers") // Output: [1, 4, 9, 16, 25]
    
    // Find even numbers
    val evenNumbers = numberList.findElements { it % 2 == 0 }
    println("Even numbers: $evenNumbers") // Output: [2, 4]
    
    // Works with any type
    data class Product(val name: String, val price: Double)
    val products = listOf(
        Product("Laptop", 1200.0),
        Product("Phone", 800.0),
        Product("Headphones", 150.0)
    )
    
    // Transform products to their names
    val productNames = products.transformList { it.name }
    println("Product names: $productNames") // Output: [Laptop, Phone, Headphones]
    
    // Find products under $500
    val affordableProducts = products.findElements { it.price < 500.0 }
    println("Affordable products: $affordableProducts") // Output: [Product(name=Headphones, price=150.0)]
}

默认值处理

Kotlin 允许函数参数声明默认值，泛型函数也一样。下面的例子展示的是两种提供回退值的方式：由调用方传入，或根据类型选择；它们没有在参数声明中使用 = 默认值。

使用场景：从数据库读取一个值，如果没有找到，就返回默认值。用泛型可以让这套逻辑适用于不同类型的数据。

提供回退值的泛型函数示例：

// Version 1: Explicit fallback value
fun <T> getValueOrDefault(value: T?, defaultValue: T): T {
    return value ?: defaultValue
}

// Version 2: More advanced approach with type-specific defaults
inline fun <reified T> getValueOrDefault(value: T?): T {
    return value ?: when (T::class) {
        String::class -> "" as T
        Int::class -> 0 as T
        Boolean::class -> false as T
        Double::class -> 0.0 as T
        List::class -> emptyList<Any>() as T
        Map::class -> emptyMap<Any, Any>() as T
        else -> throw NotImplementedError("No default value for type ${T::class.simpleName}")
    }
}

fun main() {
    // Version 1: Using explicit defaults
    println(getValueOrDefault("Hello", "Default")) // Output: Hello
    println(getValueOrDefault(null, "Default"))    // Output: Default
    
    // Version 2: Using type-specific defaults (explicit type shown here)
    println(getValueOrDefault<String>("Hello"))    // Output: Hello
    println(getValueOrDefault<String>(null))       // Output: "" (empty string)
    println(getValueOrDefault<Int>(null))          // Output: 0
    println(getValueOrDefault<Boolean>(null))      // Output: false
    
    // Custom types with Version 1
    data class User(val name: String)
    val defaultUser = User("Anonymous")
    println(getValueOrDefault(null, defaultUser))  // Output: User(name=Anonymous)
}

这个例子给出了两个版本：

版本一：调用方显式传入默认值，可以用于任意类型。

版本二：使用 reified 类型参数，根据类型自动选择默认值。

版本一每次调用都要传入默认值，例如 getValueOrDefault("Hello", "Default")。

版本二不需要传入默认值。示例显式指定了类型；如果编译器能从实参或上下文推断出 T，也可以省略类型实参。

你可以根据需要选择：显式提供默认值，或由函数根据类型选择默认值。第二种写法只支持 when 中列出的类型，其余类型在值为 null 时会抛出异常。

第二种写法只是有限类型的示例，不能当作通用默认值工厂。T::class 不包含 List<String> 等类型的元素类型信息，emptyList() 和 emptyMap() 返回的也是只读集合。Kotlin/JVM 上，可变与只读集合映射到相同的 Java 接口，仅判断 T::class 无法区分它们；例如请求 MutableList<Int> 的默认值时，这里的转换会失败。需要可变集合或其他类型时，应使用版本一，显式提供符合 T 的回退值。

这里要区分两个问题：

普通泛型函数可以接收一个 T 类型的回退值；参数默认值也可以是表达式或函数调用，并不要求必须是具体常量。

如果要在函数体中使用 T::class 判断类型，则需要 inline 和 reified。

不变性（Invariance）

不变性（Invariance）指的是：即使两个类型参数之间存在子类型关系，使用它们的同一个泛型类型也不会因此产生子类型关系。

Kotlin 自定义泛型类型默认是不变的。

例如：如果容器类型是不变的，那么存放字符串的容器就不能直接传给接收 Container<Any> 的函数。这种限制用于保证类型安全。

这里需要区分具体声明：Kotlin 的只读 List 声明了协变，List<String> 可以赋给 List<Any>；MutableList 则是不变的。

class Container<T>(val value: T)

fun main() {
    val stringContainer: Container<String> = Container("Hello")
    val anyContainer: Container<Any> = stringContainer // Error: Type mismatch
    val anyContainerCorrect: Container<Any> = Container<Any>("Hello")
    println(anyContainerCorrect.value) // Output: Hello
}

Container<String> 不是 Container<Any> 的子类型，这体现了自定义泛型类型默认的不变性。上面的错误赋值是故意保留的反例，运行其余代码前需要注释掉这一行。

型变（Variance）

Kotlin 使用 out、in 和星投影 * 来表达泛型的型变与投影。

型变是指：类型参数之间的子类型关系，如何影响包含这些参数的泛型类型之间的关系。

1. out：协变

协变会保留类型参数之间的子类型关系。例如，Apple 是 Fruit 的子类型，那么协变类型 Producer<Apple> 也是 Producer<Fruit> 的子类型。

Kotlin 用 out 声明这种关系。

例如，你有一个 Apple 列表，需要将它传给接收只读 List<Fruit> 的方法。

open class Fruit

class Apple : Fruit()

class FruitProducer<out T : Fruit>(private val fruit: T) {
    fun produce(): T {
        return fruit
    }
}

fun main() {
    val appleProducer: FruitProducer<Apple> = FruitProducer(Apple())
    val fruitProducer: FruitProducer<Fruit> = appleProducer
    println(fruitProducer.produce()) // Prints an Apple instance; exact text varies
}

FruitProducer<out T> 声明了协变，因此可以把 FruitProducer<Apple> 赋给 FruitProducer<Fruit>。

这个很好理解，对于生产者（向外产生值），假设我规定了只能给你水果（fruitProducer），那么无论我给你苹果（appleProducer），还是梨子，都是合理的。

处理集合和类型层级时，这种关系很有用。

2. in：逆变

逆变会反转类型参数之间的子类型关系。

例如，Apple 是 Fruit 的子类型，那么逆变类型 Consumer<Fruit> 是 Consumer<Apple> 的子类型（倒反天罡）。

Kotlin 用 in 声明这种关系，常用于消费输入值的类型。

例如：一个消费者能处理所有 Fruit，当然也能处理 Apple。

逆变允许你把这个 Fruit 消费者用在要求 Apple 消费者的位置。单纯给接收 Fruit 的函数传入 Apple，本身只需要普通的子类型关系。

open class Fruit

class Apple : Fruit()

class FruitConsumer<in T : Fruit> {
    fun consume(fruit: T) {
        println("Consuming a fruit")
    }
}

fun main() {
    val fruitConsumer: FruitConsumer<Fruit> = FruitConsumer()  // FruitConsumer can consume any Fruit
    val appleConsumer: FruitConsumer<Apple> = fruitConsumer    // Contravariance allows this

    appleConsumer.consume(Apple())  // Output: Consuming a fruit
}

FruitConsumer<in T> 允许把 FruitConsumer<Fruit> 赋给 FruitConsumer<Apple>。这样，能处理一般类型的消费者也可以用于只要求处理某个子类型的场景。

用上面这个例子来讲，我说我可以处理水果（fruitConsumer），那么肯定也能处理苹果呀（appleConsumer）！

如果还不好理解，可以想象一个 MutableList<Fruit>：既然能添加水果，那么也能添加苹果。你可以把它赋给 MutableList<in Apple>，通过这个引用添加 Apple，但读取元素时只能得到 Any?。

同时使用 out 和 in

下面通过接口，把协变和逆变放在同一个例子中：

例如，系统既需要生产不同类型的对象，也需要消费它们：工厂生产 Fruit，商店消费这些对象。

open class Fruit

class Apple : Fruit()

interface Source<out T> {
    fun next(): T
}

interface Sink<in T> {
    fun accept(item: T)
}

fun <T> feedSink(item: T, sink: Sink<T>) {
    sink.accept(item)
}

fun main() {
    val stringSource: Source<String> = object : Source<String> {
        override fun next(): String = "Kotlin"
    }
    val anySource: Source<Any> = stringSource
    println(anySource.next()) // Output: Kotlin

    val fruitSink: Sink<Fruit> = object : Sink<Fruit> {
        override fun accept(item: Fruit) {
            println("Consuming a fruit")
        }
    }
    val appleSink: Sink<Apple> = fruitSink

    feedSink(Apple(), appleSink)
}

在这个例子中：

Source<out T> 是协变的，因此 Source<String> 可以赋给 Source<Any>。

Sink<in T> 是逆变的，因此 Sink<Fruit> 可以赋给 Sink<Apple>。

Kotlin 中，生产者常用协变，消费者常用逆变。可以这样记：

类只返回（生产）T 类型的值时，使用 out。

类只接收（消费）T 类型的值时，使用 in。

类既生产又消费 T 类型的值时，通常不声明型变。

这个记法与 Java 中的 PECS 原则相对应。不过，Java 的通配符用于使用处，前面的 Kotlin 接口是在声明处指定型变：

Producer Extends, Consumer Super

• Producer （生产者）→ Extends ：如果泛型对象主要用于生产（提供）数据，使用 ? extends T。
• Consumer （消费者）→ Super ：如果泛型对象主要用于消费（接收）数据，使用 ? super T。

理解这些关系，有助于设计类型安全、方便调用的 API，尤其是在处理集合和类型层级时。

理解 where 子句

where 可以为类型参数设置多个约束，也就是要求一个类型同时具备几种能力。

where 子句是什么

假设你需要一个类型，它既是 Animal，又能参与比较，以便找出年龄最大的动物。where 可以同时表达这两个要求。

下面的函数从列表中找出年龄最大的动物。比较年龄时使用 compareTo，避免原文直接相减可能出现的整数溢出：

// Base animal class with age
open class Animal(val age: Int)

// Dog class that extends Animal and can be compared
class Dog(age: Int) : Animal(age), Comparable<Dog> {
    override fun compareTo(other: Dog): Int {
        return this.age.compareTo(other.age)
    }
}

// Function to find the oldest animal
// The "where" clause requires T to be BOTH:
// 1. A type of Animal AND
// 2. Something that can be compared
fun <T> findOldestAnimal(animals: List<T>): T where T : Animal, T : Comparable<T> {
    return animals.maxByOrNull { it.age } ?: throw IllegalArgumentException("List is empty")
}

fun main() {
    val dogs = listOf(Dog(5), Dog(3), Dog(9), Dog(7))
    val oldestDog = findOldestAnimal(dogs)
    println("The oldest dog is ${oldestDog.age} years old.") // Output: The oldest dog is 9 years old.
}

接下来的 Healthy 接口会增加 healthScore 属性，用来判断动物是否健康。

HealthyDog 会继承 Animal，实现用于年龄比较的 Comparable<HealthyDog>，并实现提供健康评分的 Healthy。

findOldestHealthyAnimal 会通过 where 要求 T 同时满足 Animal、Comparable<T> 和 Healthy 三个约束，以便先按健康评分筛选，再找出年龄最大的动物。

例如：找出年龄最大的健康动物

// Health interface with a health score
interface Healthy {
    val healthScore: Int
}

// HealthyDog that is an Animal, can be compared, and has health info
class HealthyDog(age: Int, override val healthScore: Int) : Animal(age), Comparable<HealthyDog>, Healthy {
    override fun compareTo(other: HealthyDog): Int {
        return this.age.compareTo(other.age)
    }
}

// Function requiring THREE conditions:
// 1. Must be an Animal AND
// 2. Must be comparable AND
// 3. Must have health information
fun <T> findOldestHealthyAnimal(animals: List<T>): T where T : Animal, T : Comparable<T>, T : Healthy {
    // Only consider animals with good health
    return animals.filter { it.healthScore > 50 }
        .maxByOrNull { it.age } ?: throw IllegalArgumentException("No healthy animals found")
}

fun main() {
    val healthyDogs = listOf(
        HealthyDog(5, 70),
        HealthyDog(3, 80),
        HealthyDog(9, 60),
        HealthyDog(7, 90)
    )
    val oldestHealthyDog = findOldestHealthyAnimal(healthyDogs)
    println("The oldest healthy dog is ${oldestHealthyDog.age} years old with a health score of ${oldestHealthyDog.healthScore}.")
    // Output: The oldest healthy dog is 9 years old with a health score of 60.
}

Healthy 接口提供 healthScore 属性，作为判断动物健康状况的依据。

HealthyDog 继承 Animal，实现 Comparable<HealthyDog> 来比较年龄，同时实现 Healthy 来提供健康评分。

findOldestHealthyAnimal 通过 where 要求 T 同时满足这三个约束，然后筛选健康评分大于 50 的动物，再找出年龄最大的那个。这里按 age 调用 maxByOrNull，并没有使用 compareTo；Comparable<T> 在这两个示例中是演示多重约束，并非函数实现所必需。

星投影

不知道确切的类型实参时，可以使用星投影 *，在保留类型安全的前提下处理未知类型。

例如：处理集合或 API 时，具体类型实参未知，或者当前操作不需要关心它，就可以使用星投影。

fun printList(list: List<*>) {
    for (item in list) {
        println(item)
    }
}

fun main() {
    val intList: List<Int> = listOf(1, 2, 3)
    val stringList: List<String> = listOf("a", "b", "c")
    printList(intList) // Output: 1, 2, 3
    printList(stringList) // Output: a, b, c
}

List<*> 表示元素类型未知的列表，可以接收不同元素类型的列表。只需要处理集合，而不关心元素的确切类型时，这种写法很方便。

什么时候使用星投影

星投影适合以下场景：

不需要类型信息：当前操作不依赖元素的具体类型。

与旧代码交互：对接使用原始类型或通配符的 Java 代码。

处理异构集合：集合中可能包含多种类型的元素。

如果你觉得 List<*> 和 List<Any> 差不多，需要先区分可空性：List<*> 读出的元素是 Any?，可能为 null；List<Any> 的元素则是非空的。对只读 List 而言，List<*> 与 List<Any?> 的读取能力相同；下面用 MutableList 看星投影对写入的限制。

星投影的限制

星投影也会限制你能执行的操作：

fun addToList(list: MutableList<*>, item: Any) {
    // This doesn't compile!
    // list.add(item)
    
    // We cannot add an element of an unknown type; clear() is still allowed
    println("The list contains ${list.size} items")
}

对于上面的 MutableList<*>，通常可以：

读取元素，得到 Any? 类型的值。

调用返回 Any? 的方法。

调用不依赖具体元素类型的方法。

但不能：

通过 add 或 set 写入元素，因为不知道列表实际接受什么类型。

调用要求你提供未知元素类型值的方法。

星投影并不意味着集合不可修改，例如仍可调用 clear()。对其他带上界的泛型类型，读取结果应按其上界理解，不一定都是 Any?。

更复杂的例子

// Function to count elements that match a specific condition
fun countElements(collection: Collection<*>, predicate: (Any?) -> Boolean): Int {
    var count = 0
    for (item in collection) {
        if (predicate(item)) {
            count++
        }
    }
    return count
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val strings = listOf("apple", "banana", "cherry", "date")
    
    // Count even numbers
    val evenCount = countElements(numbers) { it is Int && it % 2 == 0 }
    println("Number of even integers: $evenCount") // Output: 2
    
    // Count strings starting with 'a'
    val aCount = countElements(strings) { it is String && it.startsWith('a') }
    println("Number of strings starting with 'a': $aCount") // Output: 1
}

这个计数函数通过星投影接收不同类型的集合，再用运行时类型检查（is）为每个元素应用条件。这里把谓词参数写成 Any?，直接传入元素，避免原文的 item!! 在遇到 null 时抛出异常。

星投影让你可以处理不同类型的数据，同时保留对未知类型所需的安全限制。

泛型约束

有时，你需要限制泛型类或函数允许使用哪些类型。可以为类型参数定义上界，让传入的类型必须满足相应要求。

使用场景：一个数学函数只适用于数值类型。可以用泛型约束，确保调用方传入 Int、Float、Double 等合适的类型。

fun <T : Number> sum(a: T, b: T): Double {
    return a.toDouble() + b.toDouble()
}

fun main() {
    println(sum(3, 4)) // Output: 7.0
    println(sum(3.5, 4.2)) // Output: 7.7
    // println(sum("3", "4")) // Error: Type inference failed
}

T : Number 将 T 限定为 Number 的子类型，因此 sum 只能接收数值类型，不能传入字符串等类型。结果统一转为 Double，大整数转换和浮点运算可能损失精度，这个函数并不保证精确求和。

加上这个约束后：

可以使用 Int、Double、Float、Long 等类型。

不能使用 String、Boolean 等非数值类型。

函数体中可以调用 Number 的方法，例如 toDouble()。

如果使用 where，可以为同一个类型参数指定多个约束。

例如：某个排序算法要求元素既能比较，又能克隆。多个约束可以确保只有同时满足这些要求的类型才能传入。

fun <T> performOperation(item: T) where T : Comparable<T>, T : Cloneable {
    // Compare the item with itself (just as an example)
    if (item.compareTo(item) == 0) {
        println("Item is equal to itself")
    }
    
    // Cloneable.clone() is protected, so this function cannot call it directly
}

fun main() {
    // This would work if String implemented Cloneable (it doesn't in reality)
    // performOperation("Hello")
    
    // For demonstration, let's create a class that meets both constraints
    class ComparableAndCloneable(val value: Int) : Comparable<ComparableAndCloneable>, Cloneable {
        override fun compareTo(other: ComparableAndCloneable): Int {
            return value.compareTo(other.value)
        }
        
        public override fun clone(): Any {
            return ComparableAndCloneable(value)
        }
    }
    
    performOperation(ComparableAndCloneable(10)) // Works because it satisfies both constraints
}

这里的 T 必须同时满足 Comparable<T> 和 Cloneable，因此 performOperation 只接受符合这两个条件的类型。

注意，Kotlin/JVM 的 Cloneable.clone() 是受保护成员，仅有这个上界不能让普通泛型函数直接调用它；强制转换成 Java 的 Cloneable 也不能解决这个问题。示例类通过公开重写 clone() 提供可调用的实现，但在泛型函数中还需要能公开表达该操作的接口或具体类型。

常见的约束类型

类约束：<T : SomeClass>。

接口约束：<T : SomeInterface>。

多个约束：<T> where T : Interface1, T : Interface2。

可空类型约束：<T : Any?> 允许可空类型，而 <T : Any> 只允许非空类型。不写上界时，默认上界就是 Any?。

泛型约束可以保留泛型的复用能力，同时让允许的类型和可执行的操作更明确。

为泛型类型参数设置多个上界

where 可以为同一个泛型类型参数设置多个上界，让它同时满足多个接口或父类约束。

使用场景：构建一个模拟系统，对象需要同时具备移动、绘制等行为。多个上界可以确保只接收具备这些能力的对象。

interface Vehicle {
    fun drive()
}

interface Electric {
    fun chargeBattery()
}
class Tesla : Vehicle, Electric {
    override fun drive() {
        println("Driving Tesla")
    }
    override fun chargeBattery() {
        println("Charging Tesla's battery")
    }
}
fun <T> operateVehicle(vehicle: T) where T : Vehicle, T : Electric {
    vehicle.drive()
    vehicle.chargeBattery()
}
fun main() {
    val tesla = Tesla()
    operateVehicle(tesla) // Output: Driving Tesla \n Charging Tesla's battery
    
    // This would cause a compile-time error:
    class GasCar : Vehicle {
        override fun drive() {
            println("Driving gas car")
        }
    }
    // operateVehicle(GasCar()) // Error: Type argument is not within bounds
}

operateVehicle 只接受同时实现 Vehicle 和 Electric 的类型。通过 where 指定这两个上界，函数就能调用驾驶和充电操作。

例如：同时约束类和接口。

abstract class Machine {
    abstract fun turnOn()
    abstract fun turnOff()
}

interface Programmable {
    fun program(task: String)
}
class Robot : Machine(), Programmable {
    override fun turnOn() {
        println("Robot powering on")
    }
    
    override fun turnOff() {
        println("Robot shutting down")
    }
    
    override fun program(task: String) {
        println("Robot programmed to: $task")
    }
}
fun <T> operateMachine(machine: T) where T : Machine, T : Programmable {
    machine.turnOn()
    machine.program("Perform assembly tasks")
    machine.turnOff()
}
fun main() {
    val robot = Robot()
    operateMachine(robot)
    // Output:
    // Robot powering on
    // Robot programmed to: Perform assembly tasks
    // Robot shutting down
}

总结

泛型初看可能有些绕，但它能让代码复用于不同类型，并保留类型检查。本文介绍了 Kotlin 泛型的基础。后面，我会再发一篇文章，讲解更多的实战案例。