🌟 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，然后慢慢尝试更复杂的场景。多泛型参数用多了，你会爱上它的！