Kotlin 语言特性分享会

1 空安全体系

可空类型 / 非空类型基础

在 Kotlin 中，类型系统默认是非空的，赋值 null 会导致编译错误。可空类型通过 ? 标记。

kotlin

fun main() {
    // 非空类型：不能赋值 null
    var normalStr: String = "Hello"
    // normalStr = null  // 编译报错

    // 可空类型：加 ? 允许为 null
    var nullableStr: String? = null
    nullableStr = "Kotlin"
}

?. 空安全调用

对象为 null 时不执行后面方法，直接返回 null，不会 NPE。

kotlin

fun main() {
    var str: String? = null

    // 安全调用：null 就短路，不报错
    val len = str?.length
    println(len) // null

    str = "Android"
    println(str?.length) // 7
}

?: Elvis 埃尔维斯运算符

为空时给默认值，语法：表达式 ?: 默认值

kotlin

fun main() {
    var str: String? = null

    // 为 null 取后面默认值
    val realStr = str ?: "默认字符串"
    println(realStr) // 默认字符串

    str = "Kotlin"
    val realStr2 = str ?: "默认字符串"
    println(realStr2) // Kotlin

    // 常用：为空直接 return
    val name: String? = null
    val info = name ?: return
    println("不会走到这里")

}

!! 非空断言

强行告诉编译器：一定不为 null，出错直接抛 NPE，慎用，业务代码尽量避免。

kotlin

fun main() {
    var str: String? = "测试"
    // 强行断言非空
    println(str!!.length)

    // 一旦真的为 null，直接崩溃 NPE
    str = null
    // println(str!!.length) // 运行时 NullPointerException
}

组合用法：?. + ?: 最常用标准写法

kotlin

fun main() {
    val str: String? = null

    // 为空调用默认值，不为空取长度
    val length = str?.length ?: 0
    println(length) // 0
}

平台类型（Java 类型坑点）
Kotlin 调用 Java 代码时，平台类型可空性模糊，容易 NPE。Java 返回的类型在 Kotlin 中可能既可以当 String 也可以当 String?。

空安全体系总结

Type? 标记可空，默认 Type 不可空
?. 安全调用，null 直接短路
?: 空就给默认值 / 空就 return
!! 强行断言，慎用，容易 NPE
优先用 ?. 和 ?:，杜绝无脑 !!

2 数据类 data class

基础定义 & 核心特性

数据类自动帮你生成 4 套方法：equals() / hashCode()、toString()、componentN() 解构、copy()

kotlin

// 数据类：主构造声明属性即可
data class User(
    val id: Long,
    val name: String,
    val age: Int
)

fun main() {
    val u1 = User(1, "张三", 20)
    val u2 = User(1, "张三", 20)

    // 1. 自动重写 equals：按属性值比较
    println(u1 == u2)       // true

    // 2. 自动友好 toString
    println(u1)             // User(id=1, name=张三, age=20)
}

解构声明 componentN

数据类自动生成 component1、component2...，支持解构赋值：

kotlin

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

fun main() {
    val user = User(10, "李四", 25)

    // 解构
    val (id, name, age) = user
    println("id=$id, name=$name, age=$age")
}

copy 拷贝 & 局部修改

不修改原对象，生成新对象，只改部分字段，常用不可变数据更新：

kotlin

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

fun main() {
    val oldUser = User(1, "王五", 30)

    // 只修改 age，其他复用原值
    val newUser = oldUser.copy(age = 31)

    println(oldUser)
    println(newUser)
}

数据类约束规则

规则	说明
主构造函数至少一个参数	必须有参数才能生成方法
参数建议用 val/var	声明为属性才能参与 equals/toString
不能被继承	不能 open、abstract、sealed
只认主构造属性	类体内属性不参与数据比较

嵌套数据类（常用接口响应封装）

kotlin

// 嵌套数据类
data class ApiResponse<T>(
    val code: Int,
    val msg: String,
    val data: T?
)

data class LoginData(
    val token: String,
    val userId: Long
)

// 模拟网络返回
fun main() {
    val resp = ApiResponse<LoginData>(
        code = 200,
        msg = "成功",
        data = LoginData("abc123", 10086)
    )
    println(resp)
}

数据类总结

data class 专为纯数据载体设计
自动生成：equals、hashCode、toString、componentN、copy
类体内定义的属性不参与数据比较
适合：接口实体、数据库实体、配置类、状态载体
不可变优先：尽量用 val 定义属性，配合 copy 做变更

3 集合

不可变集合 vs 可变集合

不可变集合（只读，不能增删改）：List / Set / Map 默认都是不可变

kotlin

fun main() {
    // 不可变 List
    val list: List<Int> = listOf(1,2,3,4)
    // list.add(5) // 编译报错：不能 add/remove

    // 不可变 Set
    val set: Set<Int> = setOf(1,2,2,3)
    println(set) // [1,2,3]

    // 不可变 Map
    val map: Map<String, Int> = mapOf("a" to 1, "b" to 2)
    println(map["a"])
}

可变集合 Mutable（可增删改）

使用 mutableListOf / mutableSetOf / mutableMapOf：

kotlin

fun main() {
    val mList = mutableListOf(1,2,3)
    mList.add(4)
    mList.remove(2)
    println(mList) // [1,3,4]

    val mSet = mutableSetOf(1,2,2)
    mSet.add(5)
    println(mSet)

    val mMap = mutableMapOf("name" to "Tom")
    mMap["age"] = 18
    println(mMap)
}

普通 List 链式调用（立即求值）

每一步操作立即生成新集合，中间产生多个临时集合，大数据量性能差。

kotlin

fun main() {
    val list = listOf(1,2,3,4,5,6)

    val result = list
        .filter { it % 2 == 0 }      // 生成新集合
        .map { it * 10 }             // 再生成新集合
        .take(2)

    println(result)
}
// 执行流程：全量过滤 → 全量映射 → 再截取，中间多轮内存分配

Sequence 序列惰性求值

asSequence() 转序列，所有操作延迟到最后终止操作才执行，中间不生成临时集合。

kotlin

fun main() {
    val list = listOf(1,2,3,4,5,6)

    val result = list.asSequence()
        .filter { it % 2 == 0 }
        .map { it * 10 }
        .take(2)
        .toList() // 终止操作，才开始真正执行

    println(result)
}

Sequence 优势场景
大数据量集合遍历、多层链式操作、有 take/first 等可以提前终止的场景，节省遍历。避免生成大量中间临时 List，内存和性能更优。

集合总结

不可变集合：listOf/setOf/mapOf，只读不可修改
可变集合：mutableListOf...，可增删改
普通 List：立即求值，每步生成中间集合，大数据性能差
Sequence：惰性求值，终止操作才执行，无中间集合，大数据优先用 Sequence
惰性：元素逐个流水线处理，支持提前截断，更省内存、更快

4 高阶函数

函数类型

kotlin

// 无参无返回
val func0: () -> Unit

// 一个参数、返回 Int
val func1: (Int) -> Int

// 多个参数
val func2: (String, Int) -> Boolean

高阶函数：把函数当参数 / 返回值

kotlin

// 接收函数作为参数
fun calculate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
    return op(a, b)
}

fun main() {
    // 传入 lambda
    val sum = calculate(2, 3) { x, y -> x + y }
    val mul = calculate(2, 3) { x, y -> x * y }

    println(sum)  // 5
    println(mul)  // 6
}

函数作为返回值

kotlin

fun getMathOp(type: String): (Int, Int) -> Int {
    return when (type) {
        "add" -> { a, b -> a + b }
        "sub" -> { a, b -> a - b }
        else -> { _, _ -> 0 }
    }
}

fun main() {
    val add = getMathOp("add")
    println(add(10, 20)) // 30
}

五大作用域函数

先记核心口诀：

函数	内部指代	返回值	适用场景
let	it	lambda 结果	判空、类型转换
run	this	lambda 结果	初始化并返回计算值
apply	this	原对象	对象配置、初始化
also	it	原对象	插日志、链式中间处理
with	this	lambda 结果	同一对象批量操作

kotlin

data class User(var name: String = "", var age: Int = 0)

// let：传 it，返回 lambda 结果
fun testLet() {
    val user: User? = User("张三", 18)
    val nameLen = user?.let {
        println(it.name)
        it.name.length
    }
    println(nameLen)
}

// run：传 this，返回 lambda 结果
fun testRun() {
    val result = User("李四", 20).run {
        age = 21
        name.length
    }
    println(result)
}

// apply：传 this，返回原对象
fun testApply() {
    val user = User().apply {
        name = "王五"
        age = 25
    }
    println(user)
}

// also：传 it，返回原对象
fun testAlso() {
    val name = User("赵六", 30)
        .also { println("修改前：${it.name}") }
        .apply { name = "赵六改名" }
        .also { println("修改后：${it.name}") }
        .name
}

// with：传入对象，内部 this，返回 lambda 结果
fun testWith() {
    val user = User()
    val info = with(user) {
        name = "小明"
        age = 19
        "姓名:$name, 年龄:$age"
    }
    println(info)
}

fun main() {
    testLet()
    testRun()
    testApply()
    testAlso()
    testWith()
}

5 扩展函数

基础概念

在不修改原类源码的前提下，给已有类新增方法。

kotlin

// 语法：fun 接收者类.方法名(参数): 返回值
// 内部 this 指代调用对象

// 给 String 扩展：判断是否为空或空白
fun String.isBlankExt(): Boolean {
    return this.isEmpty() || this.isBlank()
}

// 给 Int 扩展：平方
fun Int.square(): Int {
    return this * this
}

fun main() {
    val str = "   "
    println(str.isBlankExt())  // true

    val num = 5
    println(num.square())      // 25
}

空安全扩展函数（可空接收者）

接收者加 ?，调用处不用判空，扩展内部自行处理 null：

kotlin

// String? 可空扩展
fun String?.orDefault(default: String = "未知"): String {
    return if (this.isNullOrBlank()) default else this
}

fun main() {
    val str1: String? = null
    val str2: String? = ""

    println(str1.orDefault())        // 未知
    println(str2.orDefault("空字符串")) // 空字符串
}

扩展属性

kotlin

data class User(var name: String = "", var age: Int = 0)

// 给 String 扩展属性
val String.lengthExt: Int
    get() = this.length.coerceAtLeast(0)

// 给 User 扩展属性
val User.isAdult: Boolean
    get() = this.age >= 18

fun main() {
    println("abc".lengthExt)   // 3
    val user = User("李四", 17)
    println(user.isAdult)      // false
}

扩展函数不能重写
扩展函数是静态解析，不是动态多态。看引用类型，不看实际对象类型。

扩展函数总结

扩展函数不修改原类源码，静态新增方法
内部用 this 指代调用者对象
可给系统类、自定义类、可空类型扩展
扩展函数静态解析，不支持多态重写
工程常用：工具类封装、UI 封装、字符串/集合扩展

6 泛型 in/out/reified

out 协变（生产者，只读）

<out T> 表示只会生产 T，不会消费 T。对应 Java 的 ? extends T。

kotlin

// 定义：只能输出 T，不能接收 T
interface Producer<out T> {
    fun produce(): T  // 只能 return T（出）
}

class FruitProducer : Producer<Fruit> {
    override fun produce(): Fruit = Fruit()
}

class AppleProducer : Producer<Apple> {
    override fun produce(): Apple = Apple()
}

// 测试协变：AppleProducer 可以赋值给 Producer<Fruit>
fun testOut() {
    val producer: Producer<Fruit> = AppleProducer()
}

open class Fruit
class Apple : Fruit()

in 逆变（消费者，只写）

<in T> 表示只会消费 T，不会生产 T。对应 Java 的 ? super T。

kotlin

// 定义：只能接收 T，不能返回 T
interface Consumer<in T> {
    fun consume(t: T)  // 只能接收 T（入）
}

class FruitConsumer : Consumer<Fruit> {
    override fun consume(t: Fruit) {
        println("吃水果")
    }
}

// 测试逆变：FruitConsumer 可以赋值给 Consumer
fun testIn() {
    val consumer: Consumer<Apple> = FruitConsumer()
}

reified 泛型实化（运行时获取泛型类型）

核心价值：解决 Java 泛型擦除问题。必须配合 inline 内联函数使用。

kotlin

// 关键：inline + reified 才能拿到 T 的真实类型
inline fun <reified T> checkType(value: Any) {
    if (value is T) {
        println("value 是 ${T::class.simpleName} 类型")
    } else {
        println("value 不是 ${T::class.simpleName} 类型")
    }
}

// 运行时获取泛型类型（最常用！）
inline fun <reified T> getType(): Class<T> {
    return T::class.java
}

// 测试
fun main() {
    checkType<String>("hello")  // 是
    checkType<Int>("abc")       // 不是

    val clazz = getType<String>()
    println("真实类型：$clazz")
}

最经典实战用法：Gson 反序列化简化
inline fun <reified T> Gson.fromJson(json: String): T { return fromJson(json, T::class.java) }
调用时超级简洁：val user = gson.fromJson<User>(json)

泛型总结

out T：生产者，只能出，子→父
in T：消费者，只能入，父→子
*：未知类型，安全只读
reified：运行时拿泛型类型，必须 + inline

7 委托 by

类委托（by 类对象）

把接口方法实现，委托给另一个已有实现的类，不用自己重写所有方法。

kotlin

// 行为接口
interface ISpeak {
    fun speak()
}

// 已有实现
class Dog : ISpeak {
    override fun speak() {
        println("狗狗汪汪叫")
    }
}

// Puppy 自己不实现 ISpeak，直接委托给 Dog
class Puppy(delegate: ISpeak) : ISpeak by delegate

fun main() {
    val dog = Dog()
    val puppy = Puppy(dog)
    puppy.speak() // 狗狗汪汪叫
}

属性委托：lazy 懒加载

只初始化一次，延迟到第一次访问时创建。只读 val 专用。

kotlin

// 懒加载委托
val lazyStr: String by lazy {
    println("只执行一次初始化")
    "我是懒加载字符串"
}

fun main() {
    println("第一次访问：")
    println(lazyStr)

    println("第二次访问：")
    println(lazyStr) // 不再执行初始化，直接拿缓存值
}

Delegates.observable 可观察属性

属性变化监听，值改变自动回调。

kotlin

import kotlin.properties.Delegates

var count: Int by Delegates.observable(0) { prop, oldValue, newValue ->
    println("属性${prop.name} 变化：$oldValue -> $newValue")
}

fun main() {
    count = 10
    count = 20
}

委托总结

类委托 by：把接口实现委托给已有对象，替代继承
属性委托 by：把属性读写逻辑交给外部类
lazy：延迟初始化、只执行一次，val 专用
observable：监听属性值变化
vetoable：拦截、驳回非法赋值

8 内联函数 inline

普通高阶函数的问题

普通高阶函数每次调用都会生成匿名内部类、创建对象、有运行时开销。

kotlin

// 普通高阶函数
fun higherFunc(block: () -> Unit) {
    println("开始")
    block()
    println("结束")
}

// 底层：会创建 Function0 匿名类，频繁调用有性能开销
higherFunc { println("执行逻辑") }

inline 内联函数

作用：编译时把函数代码直接拷贝到调用处，不生成匿名类、不创建对象，消除 Lambda 开销。

kotlin

// 加 inline 变成内联函数
inline fun inlineHigherFunc(block: () -> Unit) {
    println("开始")
    block()
    println("结束")
}

// 编译后等价直接把代码平铺进来，无 Lambda 对象
inlineHigherFunc {
    println("内联执行逻辑")
}

noinline / crossinline

关键字	作用	场景
noinline	指定某个 Lambda 不内联	需要赋值给变量、传递时用
crossinline	禁止非局部 return	Lambda 在嵌套作用域调用时用

内联函数总结

inline：编译代码拷贝，消除 Lambda 匿名类开销，支持非局部 return
noinline：指定某个 Lambda 不内联，允许赋值、传递
crossinline：允许在嵌套作用域调用，禁止非局部 return

9 密封类 sealed

密封类基础

密封类：子类受限、只能在同文件内继承，适合 when 穷尽分支，可以携带不同数据。

kotlin

// 密封类：页面请求状态
sealed class PageState {
    object Loading : PageState()
    object Empty : PageState()
    data class Success<T>(val data: T) : PageState()
    data class Error(val msg: String, val code: Int) : PageState()
}

// when 自动穷尽分支，不用写 else
fun handleState(state: PageState) {
    when (state) {
        is PageState.Loading -> println("加载中")
        is PageState.Empty -> println("暂无数据")
        is PageState.Success<*> -> println("成功：${state.data}")
        is PageState.Error -> println("失败：${state.code} ${state.msg}")
    }
}

枚举 vs 密封类选型

场景	推荐
固定常量标识，不需要携带自定义数据	枚举 Enum
每个分支需要携带不同类型、不同数量数据	密封类 Sealed

密封类总结

枚举 Enum：固定常量、统一属性、不能差异化携带复杂数据
密封类 sealed class：同文件受限子类、各分支自由带数据
状态管理优先用密封类，固定常量优先用枚举

10 值类 value class

基础特性

kotlin

// 定义 value class，只能包装单个只读属性
value class UserId(val id: Long)
value class Email(val value: String)

fun main() {
    val uid = UserId(10086L)
    println(uid.id)
}

// 核心差异：
// data class：生成实体对象，有堆内存分配
// value class：编译期擦除为原始基础类型，运行时无额外对象，零开销

value class vs typealias
typealias 只是别名，无类型安全；value class 是真类型，强类型安全，编译做类型校验。

值类总结

value class：单属性、零开销、强类型、编译解包
适合：ID、手机号、邮箱、订单号等基础类型强语义封装

1 协程基础构建器

runBlocking

阻塞当前线程，直到内部所有协程执行完。用来：普通阻塞代码桥接挂起函数/协程。适用：main 函数测试、单元测试。

kotlin

import kotlinx.coroutines.*

fun main() {
    println("main 开始")

    // 阻塞主线程，等里面协程全部跑完才往下走
    runBlocking {
        println("${System.currentTimeMillis()}: 协程开始")
        delay(1000) // 挂起，不阻塞线程
        println("${System.currentTimeMillis()}: 协程结束")
    }

    println("main 结束")
}

GlobalScope 全局作用域

生命周期跟 App 全程一致，不受页面/组件生命周期管控，无法自动取消，容易内存泄漏。业务开发禁止使用。

GlobalScope 禁止用于业务代码！
正规开发用：viewModelScope / lifecycleScope / 自定义 CoroutineScope。

特性	runBlocking	GlobalScope
是否阻塞当前线程	阻塞等待协程完成	不阻塞，直接放行
生命周期	代码块级别	全局 App 生命周期
能否自动取消	随作用域自动结束	不会自动取消
使用场景	测试、main 函数	几乎不用，面试坑点
推荐程度	测试可用	业务禁止使用

2 协程作用域 CoroutineScope

核心概念

协程都必须跑在某个作用域 CoroutineScope 里
作用域取消 → 内部所有子协程全部自动取消
父子协程生命周期绑定，杜绝 GlobalScope 那种后台乱跑、内存泄漏

自定义 CoroutineScope

kotlin

import kotlinx.coroutines.*

// 1. 自定义业务作用域
val myScope = CoroutineScope(Dispatchers.IO)

fun main() {
    myScope.launch {
        delay(3000)
        println("子协程1 执行完成")
    }

    // 关键：取消作用域，所有子协程全部一并取消
    myScope.cancel()
}

协程作用域总结

CoroutineScope：协程运行的容器
结构化并发：作用域取消 → 内部所有子协程自动取消
viewModelScope：封装好的作用域，ViewModel 销毁自动取消
lifecycleScope：绑定 Activity/Fragment 生命周期
禁止用 GlobalScope：无生命周期管控，易内存泄漏

3 调度器 Dispatcher

调度器	用途	适用场景
Dispatchers.Main	主线程	更新 UI、回调页面
Dispatchers.IO	IO 阻塞任务	网络、数据库、文件、SP
Dispatchers.Default	CPU 计算任务	大数据循环、排序、解析
Dispatchers.Unconfined	不绑定线程	框架底层用，业务尽量不用

线程切换经典写法（Android 标准模板）

kotlin

import kotlinx.coroutines.*

suspend fun netRequest(): String {
    // 切IO线程做网络/数据库
    return withContext(Dispatchers.IO) {
        delay(1000)
        "接口返回数据"
    }
}

fun main() {
    runBlocking {
        // Main 环境
        launch(Dispatchers.Main) {
            println("主线程：开始请求")

            val result = netRequest()

            // 自动切回 Main 主线程
            println("主线程：更新UI -> $result")
        }
    }
}

4 协程上下文 CoroutineContext

常见元素

Dispatcher：调度器（线程）
Job：协程生命周期、取消、父子关系
CoroutineName：协程名称，调试日志用
CoroutineExceptionHandler：异常捕获处理器

语法：多个元素用 + 合并

kotlin

import kotlinx.coroutines.*

fun main() {
    runBlocking {
        // 组合上下文：调度器 + 协程名
        val myContext = Dispatchers.IO + CoroutineName("MyCustomCoroutine")

        launch(myContext) {
            println("协程名称: ${coroutineContext[CoroutineName]?.name}")
            println("当前线程: ${Thread.currentThread().name}")
        }
    }
}

协程上下文总结

CoroutineContext 是多个上下文元素的集合，可用 + 合并
子协程默认继承父协程上下文，可局部覆盖单个元素
withContext 只替换指定上下文元素，其余继承

5 回调转协程

方法	作用
cont.resume(T)	恢复协程，返回正常结果
cont.resumeWithException(e)	恢复协程，抛出异常
cont.isActive	判断协程是否仍活跃（未取消）
cont.invokeOnCancellation {}	协程取消时回调，用来销毁底层任务

工程通用封装模板
suspendCancellableCoroutine 是推荐用法，协程取消时可取消原始任务、解绑回调。

回调转协程总结

suspendCoroutine：不支持协程取消，简单临时使用
suspendCancellableCoroutine：支持协程取消，工程必用
必须判断 isActive，防止协程取消后还回调 resume

6 协程取消与超时

kotlin

fun testCoroutineCancel() = runBlocking {
    val job = launch {
        repeat(10) {
            delay(300) // 挂起函数，可响应取消
            println("协程运行中：$it")
        }
    }

    delay(1000)
    job.cancel() // 发起取消
}

// withTimeoutOrNull 超时返回 null（工程最常用）
suspend fun requestData(): String {
    delay(2000)
    return "接口成功数据"
}

fun testWithTimeoutOrNull() = runBlocking {
    val result = withTimeoutOrNull(1000) {
        requestData()
    }
    if (result == null) {
        println("请求超时，放弃处理")
    }
}

非挂起代码无法被取消
纯 CPU 循环、无挂起函数，不会响应 cancel。协程取消只在挂起函数处生效。

协程取消与超时总结

cancel()：发送取消信号，不等待协程结束
cancelAndJoin()：取消并阻塞等待协程完全结束
可取消前提：协程必须在挂起函数处才能响应取消
withTimeoutOrNull：超时返回 null，业务首选

7 异步并发操作

kotlin

import kotlinx.coroutines.async

fun testAsyncAwait() = runBlocking {
    val time = measureTimeMillis {
        // 同时开启两个并发任务
        val deferred1 = async { task1() }
        val deferred2 = async { task2() }

        // 等待两个任务都完成，拿结果
        val r1 = deferred1.await()
        val r2 = deferred2.await()
        println("$r1 , $r2")
    }
    println("async 并发总耗时：$time ms")
}

// withContext 官方推荐写法（替代不必要的 async）
suspend fun doNetWork(): String = withContext(Dispatchers.IO) {
    delay(1000)
    "网络请求结果"
}

async + await：用于多任务并行并发
withContext：单个任务线程切换+返回结果首选

异步并发总结

async + await：用于多任务并行并发
错误写法：async{}.await() 立刻等待，会退化成串行
withContext：单个任务线程切换+返回结果首选
多个接口同时请求 → async/await；单个网络请求 → withContext

8 Job 与子协程

为什么 ViewModel 要用 SupervisorJob？
多个网络请求互不影响，一个接口失败不把其他正常请求也干掉，页面销毁统一全部取消。

kotlin

// SupervisorJob 监督作业：子崩溃不传染
val supervisorScope = CoroutineScope(SupervisorJob())

supervisorScope.launch {
    // 子1 正常跑
    launch { /* ... */ }

    // 子2 主动崩溃
    launch {
        delay(800)
        throw RuntimeException("子2 崩溃")
    }
}
// 子2 崩了，子1 照样正常跑完，父作用域也不崩溃

Job 与子协程总结

普通 Job：父取消→子全取消；子异常→父和所有子一起崩溃
SupervisorJob / supervisorScope：隔离子异常，一个崩不影响其他
结构化并发：用作用域+Job 管控生命周期，杜绝内存泄漏

9 协程异常处理

协程默认异常传播规则
子协程抛异常 → 向上传递给父协程 → 父崩溃 → 所有兄弟子协程一并取消 → App 闪退

kotlin

// CoroutineExceptionHandler 全局异常捕获
val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
    println("捕获协程异常：${throwable.message}")
}

// 根协程绑定异常处理器
launch(Dispatchers.IO + exceptionHandler) {
    delay(500)
    throw RuntimeException("根协程业务异常")
}

协程异常处理总结

默认异常传播：子异常向上传递 → 父崩溃 → App 闪退
CoroutineExceptionHandler：只能捕获根协程异常
supervisorScope：隔离子协程异常，一个崩溃不影响其他

10 流 Flow

Flow 核心概念

冷流 Flow：订阅（collect）后才开始发射数据，无订阅不生产
热流 SharedFlow / StateFlow：无需订阅也能发数据，多订阅者共享

kotlin

// 基础冷流
fun numFlow(): Flow<Int> = flow {
    emit(1)
    delay(500)
    emit(2)
    emit(3)
}

// 热流 SharedFlow 事件总线
val eventFlow = MutableSharedFlow<String>()

// 订阅者1
launch { eventFlow.collect { println("订阅者1收到：$it") } }
// 订阅者2
launch { eventFlow.collect { println("订阅者2收到：$it") } }

// 发事件，所有订阅者都收到
eventFlow.emit("登录成功事件")

// StateFlow 状态订阅（替代 LiveData）
val stateFlow = MutableStateFlow(0)
stateFlow.value = 1

特性	Flow	LiveData	RxJava
归属	Kotlin 官方协程	Android Jetpack	三方框架
冷热流	冷/热皆有	热流	冷热皆有
生命周期	可配合作用域自动取消	绑定生命周期	需手动管理
推荐度	官方首选	老项目兼容	新项目不再推荐

Flow 总结

冷 Flow：订阅才发射，每次订阅重新走一遍
SharedFlow：热流，多订阅者共享，事件总线
StateFlow：热流，有初始值，新订阅者立刻收到最新值，替代 LiveData
新项目用 Flow + StateFlow/SharedFlow 完全替代 LiveData 和 RxJava

Kotlin 语言特性分享会

基础特性

可空类型 / 非空类型 基础

?. 空安全调用

?: Elvis 埃尔维斯运算符

!! 非空断言

组合用法：?. + ?: 最常用标准写法

空安全体系总结

基础定义 & 核心特性

解构声明 componentN

copy 拷贝 & 局部修改

数据类约束规则

嵌套数据类（常用接口响应封装）

数据类总结

不可变集合 vs 可变集合

可变集合 Mutable（可增删改）

普通 List 链式调用（立即求值）

Sequence 序列 惰性求值

集合总结

函数类型

高阶函数：把函数当参数 / 返回值

函数作为返回值

五大作用域函数

基础概念

空安全扩展函数（可空接收者）

扩展属性

扩展函数总结

out 协变（生产者，只读）

in 逆变（消费者，只写）

reified 泛型实化（运行时获取泛型类型）

泛型总结

类委托（by 类对象）

属性委托：lazy 懒加载

Delegates.observable 可观察属性

委托总结

普通高阶函数的问题

inline 内联函数

noinline / crossinline

内联函数总结

密封类基础

枚举 vs 密封类 选型

密封类总结

基础特性

值类总结

协程 Coroutine

runBlocking

GlobalScope 全局作用域

核心概念

自定义 CoroutineScope

协程作用域总结

线程切换经典写法（Android 标准模板）

常见元素

协程上下文总结

回调转协程总结

协程取消与超时总结

异步并发总结

Job 与子协程总结

协程异常处理总结

Flow 核心概念

Flow 总结

可空类型 / 非空类型基础

Sequence 序列惰性求值

枚举 vs 密封类选型