2-2-6 快速掌握Kotlin-语言的多泛型参数学习

🌟 Kotlin多泛型参数：让代码更灵活、更强大！

嘿！看到你对Kotlin多泛型参数感兴趣，太棒了！这可是Kotlin的高阶技巧，能让你的代码既优雅又安全，再也不用为每种类型写重复代码啦～ 😄

🧪 什么是多泛型参数？

多泛型参数就是在一个类、接口或函数中同时使用多个类型参数。想象一下，你有一个"万能盒子"，不仅能装苹果，还能装香蕉，甚至能装手机！多泛型参数就是让你的代码能同时处理多种不同类型的数据。

📝 基本语法

在Kotlin中，多泛型参数的定义非常简单，只需要在类/接口/函数名前用逗号分隔多个类型参数：

kotlin 复制代码

// 多泛型参数类
class Box<T, U>(val item1: T, val item2: U)

// 多泛型参数函数
fun <T, U> combine(item1: T, item2: U): Pair<T, U> {
    return Pair(item1, item2)
}

🎯 实际示例

1. 简单的多泛型类

kotlin 复制代码

class Pair<T, U>(val first: T, val second: U) {
    fun swap(): Pair<U, T> = Pair(second, first)
    override fun toString(): String = "($first, $second)"
}

fun main() {
    // 多种类型组合
    val stringIntPair = Pair("Hello", 42)
    val boolStringPair = Pair(true, "Kotlin")
    
    println(stringIntPair) // (Hello, 42)
    println(stringIntPair.swap()) // (42, Hello)
    println(boolStringPair) // (true, Kotlin)
}

2. 多泛型参数的类型约束

kotlin 复制代码

// T必须实现Comparable，U必须是Any（非空类型）
class BoxWithConstraint<T : Comparable<T>, U : Any>(val value1: T, val value2: U) {
    fun compare(): Boolean = value1 > value2 as T // 注意：这里需要类型转换
}

fun main() {
    // 有效使用
    val box1 = BoxWithConstraint(10, "Number") // T=Int, U=String
    
    // 无效使用：String不能实现Comparable<String>
    // val box2 = BoxWithConstraint("Hello", "World") // 编译错误
    
    // 有效使用：String可以实现Comparable<String>
    val box3 = BoxWithConstraint("Apple", "Banana") // T=String, U=String
    println(box3.compare()) // false
}

3. 多泛型参数函数

kotlin 复制代码

// 多泛型参数函数
fun <T, U> createTuple(item1: T, item2: U): Pair<T, U> {
    return Pair(item1, item2)
}

fun <T, U> compareItems(item1: T, item2: U): Boolean where T : Comparable<T>, U : Comparable<U> {
    return item1 > item2
}

fun main() {
    // 类型推断
    val tuple1 = createTuple(10, "Hello") // (10, Hello)
    val tuple2 = createTuple(true, 3.14) // (true, 3.14)
    
    // 使用类型约束
    val result1 = compareItems(10, 5) // true
    val result2 = compareItems("apple", "banana") // false
}

🔒 多泛型参数的类型约束

在多泛型参数中，每个类型参数都可以有自己的上界约束，使用where关键字：

kotlin 复制代码

fun <T, U> combineAndProcess(
    item1: T, 
    item2: U,
    processor: (T, U) -> String
): String where T : Comparable<T>, U : CharSequence {
    return processor(item1, item2)
}

fun main() {
    // 只能处理Comparable和CharSequence类型
    val result = combineAndProcess(
        42, 
        "Hello", 
        { t, u -> "Number: $t, String: $u" }
    )
    println(result) // Number: 42, String: Hello
}

💡 为什么需要多泛型参数？

更精确的类型控制：可以为不同类型的参数设置不同的约束
增强代码复用性：一个类/函数可以处理多种不同类型组合
提高类型安全性：编译器在编译时就能检查类型是否匹配
代码更清晰：明确表示函数/类能处理哪些类型的组合

🌈 实际应用场景

1. 数据仓库

kotlin 复制代码

class DataStore<K, V> {
    private val data = mutableMapOf<K, V>()
    
    fun set(key: K, value: V) {
        data[key] = value
    }
    
    fun get(key: K): V? {
        return data[key]
    }
}

fun main() {
    // 字符串作为键，整数作为值
    val stringIntStore = DataStore<String, Int>()
    stringIntStore.set("one", 1)
    stringIntStore.set("two", 2)
    
    // 字符串作为键，字符串作为值
    val stringStringStore = DataStore<String, String>()
    stringStringStore.set("name", "Alice")
    stringStringStore.set("age", "30")
}

2. 通用比较器

kotlin 复制代码

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

fun main() {
    val comparator = Comparator<Int, String>()
    // 注意：Int和String不能直接比较，但这里只是示例
    // 实际使用中，需要确保类型兼容
}

📌 多泛型参数 vs 单泛型参数

特性	单泛型参数	多泛型参数
适用场景	处理单一类型数据	处理多种类型数据组合
代码复用性	有限	高
类型约束	每个参数只能有一个约束	每个参数可以有自己的约束
代码复杂度	低	中等
适用场景	简单容器、通用函数	复杂数据结构、组合处理

💡 小贴士

类型参数命名 ：通常用单个大写字母，如T、U、V、K（Key）、V（Value）
合理使用约束：不要过度约束，否则会限制函数的使用场景
类型推断：Kotlin会自动推断类型，所以通常不需要显式指定
避免过度使用：如果不需要处理多种类型，单泛型参数就足够了

🌟 一个小练习

试试看，写一个Triple类，它能存储三个不同类型的值：

kotlin 复制代码

class Triple<T, U, V>(val first: T, val second: U, val third: V) {
    fun swapFirstTwo(): Triple<U, T, V> = Triple(second, first, third)
    override fun toString(): String = "($first, $second, $third)"
}

fun main() {
    val triple = Triple(10, "Hello", true)
    println(triple) // (10, Hello, true)
    println(triple.swapFirstTwo()) // (Hello, 10, true)
}

📚 总结

Kotlin的多泛型参数是一个非常强大的特性，它让我们的代码能够处理更复杂的类型组合，同时保持类型安全。通过合理使用多泛型参数，我们可以编写出更通用、更安全、更易维护的代码。

💡 小建议 ：在实际项目中，先从简单的多泛型参数类开始，比如Pair，然后慢慢尝试更复杂的场景。多泛型参数用多了，你会爱上它的！