2-2-5 快速掌握Kotlin-语言的泛型函数

🌟 Kotlin泛型函数：让代码更优雅、更安全！

嘿，看到你对Kotlin泛型函数感兴趣，我太开心了！这可是Kotlin最酷的特性之一，能让你的代码既安全又灵活，再也不用担心类型转换的烦恼啦～ 😄

🧪 什么是泛型函数？

泛型函数就是可以处理任意类型数据的函数。就像一个万能工具，可以处理字符串、整数、自定义对象等等，而不用为每种类型写重复代码。

📝 基本语法

在Kotlin中，定义泛型函数需要在函数名前声明类型参数：

kotlin 复制代码

fun <T> printItem(item: T) {
    println(item)
}

这里的<T>就是类型参数，T可以是任何类型。

🧪 简单示例

kotlin 复制代码

fun <T> printItem(item: T) {
    println("Item: $item, Type: ${item::class.simpleName}")
}

fun main() {
    printItem(42)            // 输出: Item: 42, Type: Int
    printItem("Hello")       // 输出: Item: Hello, Type: String
    printItem(true)          // 输出: Item: true, Type: Boolean
}

看到没？一个函数就能处理所有类型的数据，而且编译器会自动识别类型，超级智能！

💡 类型推断：Kotlin的贴心小助手

Kotlin的编译器非常聪明，能自动推断类型，所以你通常不需要显式指定类型：

kotlin 复制代码

fun <T> printItem(item: T) {
    println(item)
}

fun main() {
    // 类型推断，不需要写 <String>
    printItem("Hello")
    
    // 也可以显式指定类型
    printItem<String>("Hello")
}

这就像你去餐厅点菜，服务员（编译器）能根据你点的菜（参数）自动知道你要什么，不需要你每次都说明。

🔒 泛型约束：给类型加个"安全帽"

有时候我们只想让函数处理特定类型的对象，这时候就需要泛型约束了：

kotlin 复制代码

// 只能处理实现了Comparable的类型
fun <T : Comparable<T>> max(a: T, b: T): T {
    return if (a > b) a else b
}

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

这里T : Comparable<T>就是约束，表示T必须是Comparable的子类型。

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

如果需要多个约束，可以用where关键字：

kotlin 复制代码

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]
}

🛠 实际应用场景

1. 通用数据处理

kotlin 复制代码

fun <T> processList(list: List<T>, processor: (T) -> Unit) {
    list.forEach(processor)
}

fun main() {
    val numbers = listOf(1, 2, 3, 4)
    val strings = listOf("a", "b", "c")
    
    processList(numbers) { println("Number: $it") }
    processList(strings) { println("String: $it") }
}

2. 通用交换函数

kotlin 复制代码

fun <T> swap(a: T, b: T): Pair<T, T> {
    return Pair(b, a)
}

fun main() {
    val (a, b) = swap("Hello", "World")
    println("$a $b") // World Hello
}

3. 序列化处理（高级用法）

kotlin 复制代码

// 使用kotlinx.serialization
fun <T> serializeData(data: T, serializer: KSerializer<T>): String {
    return Json.encodeToString(serializer, data)
}

fun main() {
    val user = User("Alice", 30)
    val json = serializeData(user, User.serializer())
    println(json) // {"name":"Alice","age":30}
}

💡 为什么泛型函数这么重要？

类型安全 ：编译时检查类型，避免运行时的ClassCastException
代码复用：一份代码处理多种类型，减少重复
消除类型转换 ：再也不用写as String这样的转换
提高可读性：代码更清晰，意图更明确

🌟 一些实用小技巧

类型参数命名 ：通常用单个大写字母，如T（Type）、E（Element）、K（Key）、V（Value）
类型推断：能推断就不用写，让代码更简洁
约束：合理使用约束，避免无限制的泛型
不要过度泛型：如果不需要处理多种类型，就不用泛型

🤔 你可能会问的问题

Q：泛型函数和普通函数有什么区别？ A：普通函数只能处理特定类型，而泛型函数可以处理任意类型，更灵活、更安全。

Q：为什么Kotlin不支持原始类型？ A：因为Kotlin从一开始就有泛型，不需要兼容Java的原始类型，所以必须指定类型实参，这样能保证类型安全。

Q：泛型函数和泛型类有什么区别？ A：泛型函数是针对函数的，可以在函数级别使用泛型；泛型类是针对类的，可以在类级别使用泛型。

🌈 小练习

试试看，写一个泛型函数，可以接受任意类型的列表，并返回列表中第一个元素：

kotlin 复制代码

fun <T> getFirstElement(list: List<T>): T? {
    return list.firstOrNull()
}

然后试试用不同类型的列表调用它：

kotlin 复制代码

fun main() {
    println(getFirstElement(listOf(1, 2, 3))) // 1
    println(getFirstElement(listOf("a", "b", "c"))) // a
}

📚 总结

Kotlin的泛型函数是编写安全、灵活、可复用代码的利器。通过类型参数，我们可以让函数处理任意类型，同时在编译时确保类型安全。这不仅减少了代码重复，还提高了代码质量。

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