2-2-4 快速掌握Kotlin-定义泛型类

Kotlin泛型类：定义与使用指南

在Kotlin中，泛型类是一种强大的特性，允许我们在类中使用类型参数，从而编写可重用、类型安全的代码。下面我将详细讲解Kotlin泛型类的定义和使用。

基本语法

Kotlin中定义泛型类的语法非常简单：

kotlin 复制代码

class ClassName<T>(parameters) { 
    // 类成员使用T作为类型
}

其中：

ClassName 是类的名称
<T> 是类型参数，T是类型参数的占位符（可以是任意字母，如T、E、K、V等）
parameters 是类的构造参数

泛型类示例

1. 简单的泛型类

kotlin 复制代码

class Box<T>(t: T) {
    var value = t
}

// 使用示例
fun main() {
    // 类型推断
    val intBox = Box(42) // 推断为 Box<Int>
    val stringBox = Box("Hello") // 推断为 Box<String>
    
    println(intBox.value) // 42
    println(stringBox.value) // Hello
}

2. 显式指定类型参数

kotlin 复制代码

class Question<T>(val questionText: String, val answer: T, val difficulty: String)

fun main() {
    // 显式指定类型
    val stringQuestion = Question<String>("What is Kotlin?", "Programming Language", "Easy")
    val intQuestion = Question<Int>("What is 2 + 2?", 4, "Easy")
    
    println(stringQuestion.answer) // Programming Language
    println(intQuestion.answer) // 4
}

3. 泛型类的构造函数

kotlin 复制代码

class Person<T>(val name: String, val details: T) {
    fun showDetails() {
        println("Name: $name, Details: $details")
    }
}

fun main() {
    val person1 = Person("Alice", 25) // T = Int
    val person2 = Person("Bob", "Software Engineer") // T = String
    
    person1.showDetails() // Name: Alice, Details: 25
    person2.showDetails() // Name: Bob, Details: Software Engineer
}

类型推断

Kotlin的编译器可以自动推断泛型类型，因此我们通常不需要显式指定类型参数：

kotlin 复制代码

// 类型推断
val box = Box(10) // 推断为 Box<Int>
val box2 = Box("Kotlin") // 推断为 Box<String>

// 如果类型推断失败，需要显式指定
val unknownBox: Box<Number> = Box(10) // 显式指定为 Number

泛型约束

有时我们需要限制泛型类型必须满足某些条件，可以使用冒号:进行类型约束：

kotlin 复制代码

// 约束T必须实现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
}

为什么使用泛型类？

类型安全 ：在编译时检查类型，避免运行时的ClassCastException
代码复用：编写一次代码，可处理多种数据类型
消除类型转换 ：无需手动进行as类型转换

实际应用场景

1. 泛型集合类

kotlin 复制代码

class GenericList<T> {
    private val items = mutableListOf<T>()
    
    fun add(item: T) {
        items.add(item)
    }
    
    fun get(index: Int): T {
        return items[index]
    }
}

fun main() {
    val stringList = GenericList<String>()
    stringList.add("Hello")
    stringList.add("Kotlin")
    
    println(stringList.get(0)) // Hello
}

2. 泛型数据仓库

kotlin 复制代码

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

fun main() {
    val userStore = DataStore<String>()
    userStore.set("name", "Alice")
    userStore.set("age", "25")
    
    println(userStore.get("name")) // Alice
    println(userStore.get("age")) // 25
}

小贴士

泛型类型参数命名 ：通常使用单个大写字母，如T（Type）、E（Element）、K（Key）、V（Value）等
类型擦除：Kotlin的泛型在运行时会被擦除，但编译器会确保类型安全
型变：Kotlin支持协变（out）和逆变（in），但这些是高级特性，初学者可以先掌握基本用法

通过使用泛型类，我们可以编写更通用、更安全的代码，减少重复代码，提高开发效率。