2-2-7 快速掌握Kotlin-泛型类型约束

🌟 Kotlin泛型类型约束：让代码更安全、更优雅！

嘿，看到你对Kotlin泛型类型约束感兴趣，太棒了！这可是Kotlin中让代码既安全又灵活的"魔法"之一，能让你的代码在编译时就避免很多类型错误，再也不用担心运行时的ClassCastException啦～ 😄

📌 什么是泛型类型约束？

泛型类型约束就是为泛型参数设置限制条件，确保传入的类型满足特定要求。就像给泛型参数加了个"安全帽"，确保它不会是"不合适的类型"。

在Kotlin中，泛型约束主要分为两种：

1. 上限约束 ：<T : UpperType> - 限制类型必须是UpperType或其子类
2. 下限约束 ：<in LowerType> - 限制类型必须是LowerType或其父类

🔥 上限约束：让类型"有上限"

什么是上限约束？

上限约束用于限制类型参数必须是某个类的子类（包括该类本身），这样我们就可以在泛型代码中安全地调用该类的方法。

使用场景

• 当泛型函数需要调用类型参数的特定方法时
• 当我们需要确保传入的类型有特定的属性或行为时

代码示例

// 上限约束为 Number，确保 T 是数字类型
fun <T : Number> sum(list: List<T>): Double {
    var total = 0.0
    for (num in list) {
        total += num.toDouble() // 调用 Number 类的 toDouble() 方法
    }
    return total
}

fun main() {
    val intList = listOf(1, 2, 3, 4)
    val doubleList = listOf(1.5, 2.5, 3.5)
    
    println(sum(intList))       // 输出：10.0
    println(sum(doubleList))    // 输出：7.5
}

为什么需要上限约束？

没有约束的情况下，我们无法安全地调用类型参数的方法：

// 错误示例：无法保证 T 有 toDouble() 方法
fun <T> sum(list: List<T>): Double {
    var total = 0.0
    for (num in list) {
        total += num.toDouble() // 编译错误！
    }
    return total
}

与Java的对比

Kotlin的上限约束比Java更强大，因为Kotlin的泛型是类型安全 的，而Java的泛型是类型擦除的。

🔥 下限约束：让类型"有下限"

什么是下限约束？

下限约束用于限制类型参数必须是某个类的父类 （包括该类本身），通常用于安全写入集合。

使用场景

• 向集合中添加元素时，确保类型兼容
• 在需要消费数据时，确保类型安全

代码示例

// 下限约束：确保 T 是 Animal 的父类
fun <T : Animal> addAnimal(animals: MutableList<T>, animal: T) {
    animals.add(animal)
}

open class Animal
class Dog : Animal()
class Cat : Animal()

fun main() {
    val animals = mutableListOf<Animal>()
    
    // 可以添加 Dog 或 Cat，因为它们是 Animal 的子类
    addAnimal(animals, Dog())
    addAnimal(animals, Cat())
    
    // 不能添加 Animal 本身，因为 Animal 是 Animal 的父类，不是子类
    // addAnimal(animals, Animal()) // 编译错误
}

与上限约束的区别

• 上限约束：<T : UpperType> - 用于读取操作
• 下限约束：<in LowerType> - 用于写入操作

🌈 多重约束：给类型加个"安全围栏"

有时候我们需要对类型参数设置多个约束，这时可以使用where关键字：

// T 必须同时是 CharSequence 和 Comparable
fun <T> copyWhenGreater(list: List<T>, threshold: T): List<String>
    where T : CharSequence, T : Comparable<T> {
    
    return list.filter { it > threshold }.map { it.toString() }
}

fun main() {
    val words = listOf("apple", "banana", "cherry")
    println(copyWhenGreater(words, "b")) // [banana, cherry]
}

为什么需要多重约束？

在实际项目中，我们经常需要处理同时满足多个条件的类型，例如：

• 一个类型既是可比较的（Comparable）
• 又是字符串（CharSequence）
• 还需要有特定的属性

💡 绝对非空类型：告别null的困扰

Kotlin中有一个特殊的类型约束，用于处理不可为空的类型：

// T 必须是非空类型（相当于 Java 的 @NotNull）
fun <T : Any> processNonNullable(value: T) {
    println(value.hashCode())
}

fun <T : Any?> processNullable(value: T) {
    value?.hashCode() // 安全调用
}

为什么需要绝对非空类型？

当需要与Java代码互操作时，特别是当Java方法使用了@NotNull注解时：

// Java 接口
interface Game<T> {
    T save(T x);
    @NotNull T load(@NotNull T x);
}

// Kotlin 实现
interface ArcadeGame<T> : Game<T> {
    override fun save(x: T): T
    override fun load(x: T & Any): T & Any // 必须使用 & Any
}

🌟 实际应用场景

1. 数值处理

// 处理数值列表
fun <T : Number> sum(list: List<T>): Double {
    return list.sumOf { it.toDouble() }
}

// 使用示例
val numbers = listOf(1, 2.5, 3)
println(sum(numbers)) // 6.5

2. 排序功能

// 排序函数，要求类型可比较
fun <T : Comparable<T>> sort(list: List<T>): List<T> {
    return list.sorted()
}

// 使用示例
val words = listOf("apple", "banana", "cherry")
println(sort(words)) // [apple, banana, cherry]

val numbers = listOf(3, 1, 2)
println(sort(numbers)) // [1, 2, 3]

3. 数据库查询

// 从数据库获取数据
fun <T : Entity> query(entityClass: Class<T>): List<T> {
    // 实际实现会查询数据库
    return emptyList()
}

// 实体类
open class Entity
class User : Entity()
class Product : Entity()

// 使用示例
val users = query(User::class.java)
val products = query(Product::class.java)

📚 总结：泛型类型约束的要点

约束类型	语法	使用场景	例子
上限约束	<T : UpperType>	读取操作，需要调用特定方法	fun <T : Number> sum(list: List<T>)
下限约束	<in LowerType>	写入操作，确保类型兼容	fun <T : Animal> addAnimal(animals: MutableList<T>, animal: T)
多重约束	where T : Type1, T : Type2	需要多个约束	where T : CharSequence, T : Comparable<T>
绝对非空	T & Any	与Java @NotNull互操作	fun load(x: T & Any): T & Any

💡 小贴士

1. 默认上界 ：如果没有指定上界，Kotlin默认是Any?（允许null）
2. 合理使用：不要过度约束，否则会限制函数的使用场景
3. 类型推断：Kotlin会自动推断类型，所以通常不需要显式指定
4. 命名约定 ：类型参数通常用单个大写字母，如T、E、K、V

🌈 一个有趣的例子

试试看，写一个泛型函数，可以比较两个可比较的对象：

fun <T : Comparable<T>> compare(a: T, b: T): Int {
    return a.compareTo(b)
}

fun main() {
    println(compare(10, 20)) // -1
    println(compare("apple", "banana")) // -1
    // println(compare(10, "20")) // 编译错误！类型不匹配
}

💬 最后想对你说

泛型类型约束是Kotlin中让代码更安全、更优雅的关键特性之一。刚开始学习时可能会觉得有点抽象，但一旦掌握了，你会发现它能让你的代码既安全又灵活，大大减少运行时错误。

💡 小建议 ：在实际项目中，先从简单的上限约束开始，比如<T : Number>，然后慢慢尝试更复杂的场景。泛型约束用多了，你会爱上它的！