Kotlin第六阶段学习内容详情

Kotlin 第六阶段学习内容详情：异常、泛型与扩展

本阶段目标是掌握 Kotlin 中处理错误、复用类型逻辑和扩展已有类型的常见方式。学完后，你可以写出更稳、更灵活、更像 Kotlin 风格的代码。

建议用时：3-5 天。

阶段目标

• 能使用 try-catch-finally 处理异常。
• 能理解 try 作为表达式的写法。
• 能写简单泛型函数和泛型类。
• 能使用扩展函数给已有类型增加能力。
• 能使用扩展属性。
• 能判断什么时候该封装函数，什么时候该写扩展。

第 1 天：异常处理

1. 为什么需要异常处理

程序运行时可能遇到不可预期的问题，比如：

• 字符串转数字失败。
• 除数为 0。
• 文件不存在。
• 网络请求失败。

异常处理用于在出错时让程序有机会继续运行或给出友好提示。

2. try-catch

fun main() {
    try {
        val number = "abc".toInt()
        println(number)
    } catch (e: NumberFormatException) {
        println("转换失败")
    }
}

3. 捕获通用异常

fun main() {
    try {
        val result = 10 / 0
        println(result)
    } catch (e: Exception) {
        println("程序出错：${e.message}")
    }
}

初学阶段可以先用 Exception，但实际开发中更推荐捕获具体异常。

4. finally

finally 中的代码无论是否出错都会执行。

fun main() {
    try {
        println("开始执行")
        val number = "abc".toInt()
        println(number)
    } catch (e: NumberFormatException) {
        println("转换失败")
    } finally {
        println("执行结束")
    }
}

5. try 作为表达式

Kotlin 中 try 可以返回结果。

fun parseNumber(text: String): Int {
    return try {
        text.toInt()
    } catch (e: NumberFormatException) {
        0
    }
}

fun main() {
    println(parseNumber("123"))
    println(parseNumber("abc"))
}

第 2 天：泛型函数

1. 什么是泛型

泛型可以让函数或类适用于多种类型。

没有泛型时，你可能要写很多重复函数：

fun firstInt(list: List<Int>): Int {
    return list[0]
}

fun firstString(list: List<String>): String {
    return list[0]
}

使用泛型后：

fun <T> first(list: List<T>): T {
    return list[0]
}

2. 泛型函数示例

fun <T> first(list: List<T>): T {
    return list[0]
}

fun main() {
    println(first(listOf(1, 2, 3)))
    println(first(listOf("Alice", "Bob")))
}

3. 可空返回值的泛型函数

如果列表可能为空，可以返回可空类型。

fun <T> firstOrNull(list: List<T>): T? {
    return if (list.isEmpty()) null else list[0]
}

fun main() {
    println(firstOrNull(listOf(1, 2, 3)))
    println(firstOrNull(emptyList<String>()) ?: "没有数据")
}

第 3 天：泛型类

1. 泛型类基础

class Box<T>(val value: T)

fun main() {
    val intBox = Box(100)
    val stringBox = Box("Kotlin")

    println(intBox.value)
    println(stringBox.value)
}

2. 结果包装类

data class Result<T>(
    val success: Boolean,
    val data: T?,
    val message: String
)

fun main() {
    val userResult = Result(
        success = true,
        data = "Alice",
        message = "查询成功"
    )

    println(userResult)
}

这种结构在接口返回、业务结果封装中很常见。

第 4 天：扩展函数

1. 什么是扩展函数

扩展函数可以在不修改原类的情况下，给某个类型增加新函数。

fun String.firstCharOrEmpty(): String {
    return if (this.isNotEmpty()) this[0].toString() else ""
}

fun main() {
    println("Kotlin".firstCharOrEmpty())
    println("".firstCharOrEmpty())
}

这里的 this 表示调用这个扩展函数的字符串对象。

2. 手机号判断扩展函数

fun String.isPhoneNumber(): Boolean {
    return this.length == 11 && this.all { it.isDigit() }
}

fun main() {
    println("13800138000".isPhoneNumber())
    println("hello".isPhoneNumber())
}

3. 可空类型扩展函数

扩展函数也可以写在可空类型上。

fun String?.orDefault(defaultValue: String = "默认值"): String {
    return this ?: defaultValue
}

fun main() {
    val name: String? = null
    println(name.orDefault("匿名用户"))
}

第 5 天：扩展属性与综合练习

1. 扩展属性

val String.firstChar: Char?
    get() = if (this.isNotEmpty()) this[0] else null

fun main() {
    println("Kotlin".firstChar)
    println("".firstChar ?: "空字符串")
}

扩展属性不能真正给对象增加存储字段，它本质上是一个计算属性。

2. 集合扩展函数

fun List<Int>.averageValue(): Double {
    return if (this.isEmpty()) 0.0 else this.sum().toDouble() / this.size
}

fun main() {
    val scores = listOf(80, 90, 100)
    println(scores.averageValue())
}

综合练习

练习 1：安全转数字

fun String.toIntOrDefault(defaultValue: Int = 0): Int {
    return try {
        this.toInt()
    } catch (e: NumberFormatException) {
        defaultValue
    }
}

fun main() {
    println("123".toIntOrDefault())
    println("abc".toIntOrDefault(-1))
}

练习 2：泛型获取第一个元素

fun <T> firstOrNull(list: List<T>): T? {
    return if (list.isEmpty()) null else list[0]
}

fun main() {
    println(firstOrNull(listOf("Alice", "Bob")))
    println(firstOrNull(emptyList<Int>()) ?: "空列表")
}

练习 3：接口结果包装

data class ApiResult<T>(
    val code: Int,
    val data: T?,
    val message: String
)

fun main() {
    val result = ApiResult(
        code = 0,
        data = listOf("Kotlin", "Java"),
        message = "success"
    )

    println(result)
}

必须掌握清单

• 能写 try-catch。
• 能理解 finally 的执行时机。
• 能把 try 当作表达式返回结果。
• 能写简单泛型函数。
• 能写简单泛型类。
• 能写扩展函数。
• 能写可空类型扩展函数。
• 能理解扩展属性不是实际字段。

常见错误

1. 泛型函数忘记声明 <T>

fun first(list: List<T>): T {
    return list[0]
}

应改为：

fun <T> first(list: List<T>): T {
    return list[0]
}

2. 误以为扩展函数能访问私有属性

扩展函数不是类内部成员，不能访问类的私有属性。

3. 误以为扩展属性能保存值

扩展属性通常只能通过 get() 计算结果，不能给对象新增真实字段。

阶段复盘问题

1. try-catch-finally 分别有什么作用？
2. try 作为表达式有什么好处？
3. 泛型解决了什么问题？
4. T? 表示什么？
5. 扩展函数适合什么场景？
6. 扩展函数里的 this 是什么？
7. 扩展属性为什么不能保存状态？