Kotlin的泛型怎么应用

在Kotlin中，泛型是一种强大的工具，它允许你在类、接口和方法中使用类型参数，从而实现代码的重用和类型安全。以下是Kotlin中泛型的一些常见应用：

1. 泛型类

你可以定义一个泛型类，使其可以处理多种类型的数据。

class Box<T>(val item: T) {
    fun getItem(): T = item
}

fun main() {
    val stringBox = Box("Hello")
    println(stringBox.getItem()) // 输出: Hello

    val intBox = Box(123)
    println(intBox.getItem()) // 输出: 123
}

2. 泛型接口

你可以定义一个泛型接口，使其实现类可以处理多种类型的数据。

interface Repository<T> {
    fun getById(id: Int): T
    fun save(item: T)
}

class UserRepository : Repository<User> {
    override fun getById(id: Int): User {
        // 实现获取用户逻辑
        return User(id, "John Doe")
    }

    override fun save(item: User) {
        // 实现保存用户逻辑
    }
}

data class User(val id: Int, val name: String)

3. 泛型函数

你可以定义一个泛型函数，使其可以处理多种类型的数据。

fun <T> printArray(array: Array<T>) {
    for (element in array) {
        println(element)
    }
}

fun main() {
    val intArray = arrayOf(1, 2, 3, 4, 5)
    printArray(intArray) // 输出: 1 2 3 4 5

    val stringArray = arrayOf("Hello", "World")
    printArray(stringArray) // 输出: Hello World
}

4. 泛型约束

你可以使用泛型约束来限制类型参数的范围。

interface Comparable<in T> {
    operator fun compareTo(other: T): Int
}

fun <T : Comparable<T>> max(a: T, b: T): T {
    return if (a.compareTo(b) > 0) a else b
}

fun main() {
    val intMax = max(1, 2)
    println(intMax) // 输出: 2

    val stringMax = max("apple", "banana")
    println(stringMax) // 输出: banana
}

5. 类型参数默认值

你可以为类型参数提供默认值，这样在使用泛型类或函数时可以省略类型参数。

class Result<out T>(val value: T) {
    companion object {
        fun <T> success(value: T): Result<T> = Result(value)
        fun <T> error(message: String): Result<Nothing> = Result(throw IllegalStateException(message))
    }
}

fun main() {
    val successResult = Result.success("Operation successful")
    println(successResult.value) // 输出: Operation successful

    val errorResult = Result.error("Operation failed")
    // println(errorResult.value) // 这行代码会抛出异常
}

通过这些示例，你可以看到Kotlin泛型的强大和灵活性。合理使用泛型可以使你的代码更加简洁、可读和可维护。