Kotlin 安卓现代开发
CHAPTER 01 · Kotlin 语言基础

变量、类型与字符串模板

一句话总览:Kotlin 用 val(只读)/ var(可变)声明变量,类型由右侧自动推断但一经确定终身不变——它是静态类型语言,不是「不写类型的动态语言」。
🪪
生活化类比
val 是塑封过的借书证:证上印的「持证人」一旦塑封就不能改;var 是白板:随时擦掉重写。类型推断像快递站自动配箱——你不用报尺寸,看物品就知道用多大箱子,但箱子选定后不能中途换型号。类比边界:塑封锁住的是「证指向谁」,不是「这个人不能动」——val 锁的是引用,对象内部照样可以变(下面有陷阱)。

1.1 val 与 var:默认用 val

Variables.kt
val name = "Kotlin"     // 只读引用,推断为 String,不能再赋值
var count = 0           // 可变变量,推断为 Int
count += 1              // ✓ var 可以改
// name = "Java"        // ❌ 编译错误:Val cannot be reassigned

val age: Int = 36       // 也可显式标注类型(类型写在名字后面)
val price = 9.9         // 小数默认推断为 Double
val big = 100L          // L 后缀 → Long
val ok = true           // Boolean

// 类型一经推断就钉死,这是静态类型:
var x = 10
// x = "hello"          // ❌ 编译错误:Int 的变量不能装 String

安卓开发中的意义:Compose 的状态、协程里的共享数据,能用 val 就用 val——不可变引用天然线程安全,读代码时也不用担心它在哪里被偷偷改了。

1.2 常用类型速查

类型说明示例备注
Int32 位整数42默认整数类型,约 ±21 亿
Long64 位整数100L时间戳、数据库 id 用它
Double双精度浮点3.14小数默认类型
Float单精度浮点3.14fCompose 动画参数常用
Boolean布尔true只有 true / false
Char单字符'A'单引号,和 String 不同
String字符串"hi"不可变,双引号

Kotlin 里「一切皆对象」:Int 也能调方法。但编译到 JVM 时,能优化成原生 int 的地方会自动优化,不必担心装箱开销;只有泛型、可空 Int? 等场景才真正装箱。

1.3 字符串模板:告别 + 拼接

Template.kt
val user = "润曦"
val n = 3
println("你好,$user")            // 变量直接 $名字
println("共 ${n + 1} 章")         // 表达式用 ${},花括号内可写任意代码
println("名字长度:${user.length}")

val json = """
  { "name": "$user" }
""".trimIndent()                  // 三引号原始字符串:不转义、保留换行
val 锁的是「箭头」,不是「盒子内部」
val list 只读引用(箭头焊死) MutableList [1, 2] list.add(3) ✓ 内容可以变 对象内部不受 val 约束 list = 新列表 ❌ 编译错误 不许换箭头指向 val = 引用不可变(shallow);要内容也不可变,用只读 List 或不可变数据类
val 只保证「箭头不换目标」,目标对象内部照样能改——这就是 val ≠ 深不可变的原因。
⚠ 高频陷阱:把 val 当成「绝对不可变」
错误认知:val list = mutableListOf(1) 后以为 list 彻底冻结 → 实际上 list.add(2) 完全合法,多线程下照样出并发问题。正确姿势:需要内容也不可变时,声明为只读 val list: List<Int> = listOf(1),或配合 data class 的全 val 属性。
✓ 记忆口诀
「默认 val,要改才 var;推断省字,类型钉死。」

1.4 随堂自测

QUIZ 1
已有 val list = mutableListOf(1, 2),下面哪行能通过编译并正常执行?
val 锁引用不锁内容:add 修改的是对象内部,合法;A/B 中的重新赋值都是换引用,编译报错。D 是把 val 误解为深不可变——这正是本章的核心陷阱。
QUIZ 2
var x = 10 之后执行 x = "hello",结果是?
Kotlin 是静态类型语言:x 在声明处被推断为 Int 并钉死,赋 String 直接编译失败,根本到不了运行时。类型推断只是「省得你写」,不是 JS/Python 那种动态类型。
CHAPTER 02 · Kotlin 语言基础

空安全:向 NPE 宣战

一句话总览:Kotlin 把「能不能为 null」写进类型系统——String 永不为 null,String? 才可能,编译器强制你先处理空再使用,把 Java 里最常见的 NullPointerException 消灭在编译期。
📮
生活化类比
非空类型是当面签收的快递:包裹必在手上,直接拆;可空类型是取件码:柜子里可能有件、也可能是空的。?. = 有件才开柜;?: = 没件就用备用品;!! = 不看柜子直接伸手抓,抓空了当场「炸」(抛 NPE)。类比边界:从 Java 代码递过来的包裹(平台类型)没贴标签,柜子里有没有件编译器也不知道——保护区外要自己留心。

2.1 可空类型与三件套:?. 、?: 、let

NullSafety.kt
var a: String = "abc"
// a = null               // ❌ 编译错误:String 不可为 null

var b: String? = "abc"    // 加 ? 才允许 null
b = null                  // ✓

// println(b.length)      // ❌ 编译错误:可空类型不能直接调方法
println(b?.length)        // 安全调用:b 为 null 时整个表达式 = null
println(b?.length ?: 0)   // Elvis:左边为 null 就用右边兜底 → 0

b?.let {                  // 非 null 才执行块,it 是「已确认非空」的 b
    println("长度 ${it.length}")
}

fun findUser(id: Int): User? = null   // 返回值可能为空,签名即文档
b?.length ?: 0 的两条执行路径
b: String? 编译器只信类型 b == null ? 运行时判断 非 null → b.length 得到真实长度 null → ?: 兜底值 0 安全落地,不崩溃 若用 b!!.length:null 时直接抛 NPE 💥
?. 与 ?: 把「空」变成一条正常分支;!! 则是把编译期的保护亲手拆掉,退回 Java 的赌命模式。

2.2 !!、lateinit 与平台类型:保护区外的三兄弟

Danger.kt
val len = b!!.length      // 非空断言:向编译器拍胸脯「一定非空」
                          // 拍错了 → 运行时 NullPointerException

// 智能转换:判空之后,编译器自动把 b 当非空用
if (b != null) {
    println(b.length)     // ✓ 不用 ?.,此作用域内 b 已被「智能转换」
}

lateinit var adapter: RecyclerAdapter   // 承诺「用之前一定初始化」
// 没初始化就访问 → UninitializedPropertyAccessException

// Java 互操作:Java 的 String 在 Kotlin 眼里是 String!(平台类型)
val s: String = javaApi.getName()   // 编译器不拦,若 Java 返回 null
// println(s.length)                // 💥 运行时才炸——空安全保护区外
⚠ 高频陷阱:把 !! 当「消除红线」工具
错误写法:编译器报空安全错误,随手补个 !! 让红线消失 → 后果:红线没了,NPE 挪到线上用户手机上炸。正确姿势:用 ?: 给默认值、?.let{} 只在非空时执行,或 requireNotNull(x){"说明"} 在入口处快速失败并留下可读信息。!! 只应出现在「逻辑上可证明非空」的极少数场合。
✓ 记忆口诀
「问号是契约:说好可能空,就必须处理空;!! 是撕毁契约,后果自负。」

2.3 随堂自测

QUIZ 1
val s: String? = null,表达式 s?.length ?: -1 的值是?
s 为 null → 安全调用 s?.length 短路返回 null → Elvis 接住 null 取右侧 -1。全程没有解引用,不会抛 NPE;0 是 Int 默认值的想当然,这里根本没走到 length。
QUIZ 2
Java 方法 String getName() 实际返回了 null,Kotlin 里写 val s: String = api.getName() 再调 s.length,会发生什么?
Java 返回的是平台类型 String!,编译器不做空检查,赋值畅通无阻;null 潜伏到 s.length 解引用时才炸。这正是「空安全只保护纯 Kotlin 边界内」的失效点,接 Java API 时要主动按可空处理。
CHAPTER 03 · Kotlin 语言基础

函数与 Lambda

一句话总览:Kotlin 的函数是「一等公民」——可以存进变量、当参数传递;Lambda 就是一段可以随身携带的代码,它是后面 Compose 与协程 API 的地基。
🍳
生活化类比
普通函数像菜谱书上的一道菜:有名字、写在固定页码,照着做。Lambda 像手写便签「打两个蛋炒一炒」:没名字,但能夹进任何菜谱里当其中一步——「把这段做法传给别人执行」就是高阶函数。默认参数像点奶茶:不说糖度就按「标准糖」来,说了就按你的来。类比边界:便签不能自己跑,必须有人(调用方)拿着它执行;Lambda 也一样,传进去不等于立刻执行。

3.1 函数声明的四种瘦身

Functions.kt
fun add(a: Int, b: Int): Int {   // 完整体:参数类型必须写,返回类型 Int
    return a + b
}
fun add2(a: Int, b: Int) = a + b // 单表达式函数:{} 和 return 都省了

fun greet(name: String, prefix: String = "你好") {  // 默认参数
    println("$prefix,$name")     // 无返回值 → 返回类型是 Unit(可省略)
}
greet("润曦")                     // 你好,润曦
greet("润曦", prefix = "早上好")  // 命名参数:跳过中间参数、可读性拉满

// 对比 Java:不用再为「少传一个参数」写一堆重载了

3.2 Lambda 与高阶函数

Lambda.kt
// Lambda:{ 参数 -> 函数体 },最后一行表达式的值就是返回值
val square: (Int) -> Int = { x -> x * x }
println(square(5))               // 25。(Int) -> Int 是「函数类型」

val sum = { a: Int, b: Int -> a + b }   // 类型也可推断

// 高阶函数:参数或返回值是函数的函数
fun calc(a: Int, b: Int, op: (Int, Int) -> Int): Int = op(a, b)
calc(3, 4) { x, y -> x + y }     // 尾随 Lambda:最后一个参数是函数时可移出括号
calc(3, 4) { x, y -> x * y }     // 同一段骨架,换一段「随身代码」

// 单参数 Lambda 有隐式名 it
listOf(1, 2, 3).filter { it > 1 }   // [2, 3],it 就是每个元素

为什么安卓必须学透它:Button(onClick = { ... })、items(list) { ... }、launch { ... }——现代安卓 API 几乎全是「传一段 Lambda 进去」的形态。

高阶函数:把「做法」当参数传进去
{ x, y -> x + y } Lambda:一段可传递的代码 { x, y -> x * y } 另一段「做法」,随换随用 calc(3, 4, op) 骨架固定:拿到 op 就执行 return op(a, b) 7 或 12 取决于传入哪段
变化的是「做法」(Lambda),不变的是「流程」(高阶函数)——这就是 Compose 声明式 API 的底层形态。
⚠ 高频陷阱:Lambda 里随手 return
错误写法:在 list.forEach { if (it < 0) return } 里想「跳过本次」→ 后果:裸 return 返回的是外层函数(非局部返回),整个循环连同后续逻辑全部终止。正确姿势:跳过本次用 return@forEach(带标签的局部返回),或者改用 filter 先过滤。
✓ 记忆口诀
「函数是值,Lambda 是匿名值;最后一个参数是 Lambda,就把它甩到括号外。」

3.3 随堂自测

QUIZ 1
fun f(x: Int, tag: String = "T") = "$tag$x",调用 f(5) 的结果是?
tag 有默认值 "T",不传就用默认;字符串模板 "$tag$x" 先拼 tag 再拼 x,得 "T5"。默认参数正是为了消灭 Java 式的一串重载。
QUIZ 2
在普通函数里执行 listOf(1,-2,3).forEach { if (it < 0) return; println(it) },输出是?
forEach 是 inline 函数,Lambda 里的裸 return 是「非局部返回」,直接返回外层函数——打印 1 后遇到 -2 就整体退出。想只跳过本次应写 return@forEach。这是 Kotlin 面试与实战双高频陷阱。
CHAPTER 04 · Kotlin 语言基础

类:data、sealed 与 object

一句话总览:现代安卓用三种类建模世界——data class 装数据、sealed class 装「有限的几种状态」、object 装全局唯一实例,UI 状态管理(Loading/Success/Error)全靠它们。
🗂️
生活化类比
data class 是标准证件照:格式统一(自动给你 equals/toString/copy),只关心「上面印了什么信息」。sealed class 是交通信号灯:只有红、黄、绿三种,不可能冒出第四种——所以处理它的 when 不用写 else,编译器帮你数完了。object 是公司的公章:全公司只有一枚,谁来了都盖同一枚。类比边界:信号灯种类固定是「编译期」固定的,运行时不会新增颜色;sealed 的子类同样必须在同一模块内声明完。

4.1 data class:一行顶 Java 一百行

User.kt
data class User(val id: Long, val name: String, val age: Int = 0)
// 自动生成:equals/hashCode(按属性比)、toString、copy、解构

val u1 = User(1, "润曦")
val u2 = u1.copy(age = 36)     // 复制并只改 age —— 不可变状态更新的标准姿势
println(u2)                    // User(id=1, name=润曦, age=36)
val (id, name) = u2            // 解构声明:按主构造参数顺序取

// Compose/ViewModel 中的黄金搭配:
// data class UiState(val loading: Boolean, val users: List<User>)
// state = state.copy(loading = false)  → 产生新对象,触发 UI 刷新
ℹ 为什么 copy 而不是直接改?
Compose 靠「状态对象换了新引用」感知变化。全 val + copy 的不可变模式让每次更新都是一个全新快照:可预测、可回溯、天然线程安全。直接改旧对象内部字段,UI 可能根本不刷新。

4.2 sealed class:把 UI 状态数清楚

UiState.kt
sealed interface UiState {                       // 密封:子类集合封闭
    data object Loading : UiState                // 无数据的状态用 data object
    data class Success(val users: List<User>) : UiState
    data class Error(val msg: String) : UiState
}

fun render(state: UiState) = when (state) {      // 穷尽所有分支
    is UiState.Loading -> "转圈"
    is UiState.Success -> "显示 ${state.users.size} 人"  // is 检查后智能转换
    is UiState.Error   -> "报错:${state.msg}"
}   // 不需要 else!以后新增子类,这里会编译报错提醒你补分支
sealed vs 普通继承:when 要不要写 else 的区别
sealed UiState Loading Success Error 子类集合封闭 → when 可穷尽,无需 else open / interface 子类A 子类B 未来随便 加子类… 谁都能继承 → when 必须 else 兜底
sealed 的价值不是「少写个 else」,而是「新增状态时编译器逼你更新每一处处理逻辑」——重构安全网。

4.3 object 与 companion object

Singleton.kt
object AppConfig {              // object = 线程安全的懒加载单例
    const val API = "https://api.example.com"   // const:编译期常量
    fun version() = "1.0"
}
AppConfig.version()             // 直接用类名调,全局仅此一份

class Repo {
    companion object {          // 伴生对象:挂在类上的「静态区」
        fun create(): Repo = Repo()
    }
}
Repo.create()                   // 像 Java 静态方法,但本质是单例对象的方法
⚠ 高频陷阱:用 object 单例持有 Context/View
错误写法:object Cache { var activity: Activity? = null } → 后果:单例生命周期 = 进程生命周期,Activity 销毁后仍被它拽着,整个页面连同 View 树内存泄漏。正确姿势:单例只存 Application Context 或纯数据;页面级依赖交给 ViewModel / Hilt 的作用域管理(第 16 章)。
✓ 记忆口诀
「data 装值,sealed 数状态,object 全局一份;状态更新用 copy,别改旧对象。」

4.4 随堂自测

QUIZ 1
给 sealed interface UiState 新增子类 Empty 后,原有那个「没写 else 的 when(state)」会怎样?
sealed 的子类集合编译期封闭,when 作为表达式必须穷尽。新增子类后所有未覆盖它的 when 直接编译失败——这是特性不是缺陷:它逼你在编译期补全每一处状态处理,而不是线上静默漏渲染。
QUIZ 2
ViewModel 里更新 UI 状态,哪种写法能让 Compose 正确刷新?
StateFlow/Compose 以「引用是否变化」判定更新:copy 生成新对象、赋新引用,必然触发刷新。B 改旧对象内部,引用没变,StateFlow 还会因 equals 相等直接吞掉这次更新;C 是泄漏加不可观察;D 与通知机制毫无关系。
CHAPTER 05 · Kotlin 进阶机制

集合与链式操作

一句话总览:Kotlin 集合分只读(List)与可变(MutableList)两套接口;数据处理用 map/filter 等链式操作代替 for 循环——「描述要什么」而不是「指挥怎么走」。
🏭
生活化类比
链式集合操作是饮料加工流水线:原料(原始 List)→ 筛掉坏果(filter)→ 榨成汁(map)→ 装瓶(toList)。每个工位只干一件事,串起来就是完整工艺。只读 List 像博物馆展柜:能看能拍照(读取/变换出新集合),不能伸手进去换展品(add/remove)。类比边界:流水线每过一站会产出一筐半成品(中间集合),工位多了会占地方——数据量大时要换「按需加工」的 Sequence(惰性序列)。

5.1 只读与可变:两套接口

Collections.kt
val ro: List<Int> = listOf(1, 2, 3)          // 只读接口:没有 add/remove
val rw: MutableList<Int> = mutableListOf(1)  // 可变接口
rw.add(2)                                    // ✓
// ro.add(4)                                 // ❌ 编译错误:接口上就没这方法

val m = mapOf("a" to 1, "b" to 2)            // to 创建 Pair,构建 Map
println(m["a"])                              // 1,下标访问
for ((k, v) in m) println("$k=$v")           // 解构遍历

// 注意:只读 ≠ 不可变!只是「这个引用不提供修改方法」
val sneak: List<Int> = rw    // 同一对象换个只读马甲
rw.add(9)                    // sneak 的内容也跟着变了!

5.2 链式操作:filter → map → 收集

Chain.kt
data class User(val name: String, val age: Int)
val users = listOf(User("甲", 17), User("乙", 25), User("丙", 31))

val names = users
    .filter { it.age >= 18 }        // 留下成年人 → 新列表
    .sortedBy { it.age }            // 按年龄升序 → 新列表
    .map { it.name }                // User → String → 新列表
// names = [乙, 丙]

users.groupBy { if (it.age >= 18) "成人" else "未成年" }  // Map<String, List>
users.associateBy { it.name }       // 按 key 建索引 Map<String, User>
users.fold(0) { acc, u -> acc + u.age }   // 聚合:初始 0 逐个累加

// 大数据量 / 长链条:asSequence() 惰性求值,逐元素过完整条链,不建中间集合
val first = users.asSequence().filter { it.age > 20 }.map { it.name }.first()
List 急切求值 vs Sequence 惰性求值
List 链:每站处理「全部元素」,产出一筐中间集合 [1,2,3,4] 原始 filter → [2,4] 中间集合①(占内存) map → [20,40] 中间集合②(占内存) first()=20 Sequence 链:每个元素独自走完整条链,first() 拿到就停 1 → 2 → …按需取 1: filter淘汰 | 2: filter通过 → map → 20 无中间集合;3、4 根本没被处理 first()=20
List 是「按工序批处理」,Sequence 是「按件流水」——链条长、数据多、只要前几个结果时,Sequence 省内存又省计算。
⚠ 高频陷阱:只读接口 ≠ 真不可变
错误认知:函数收到 List 参数就以为绝对安全 → 后果:调用方传进来的其实是 MutableList 的只读引用,外面一 add,你手里的数据「隔空变化」,RecyclerView/Compose 列表出现幽灵刷新或越界。正确姿势:跨边界传递时防御性拷贝 toList(),或团队约定状态一律用 listOf 构建。
✓ 记忆口诀
「filter 挑人,map 换装,fold 汇总;链长量大,asSequence 上场。」

5.3 随堂自测

QUIZ 1
listOf(1,2,3,4).filter { it % 2 == 0 }.map { it * 10 } 的结果是?
filter 先留偶数 [2,4],map 再把每个乘 10 得 [20,40]。A 忘了 filter,C 忘了 map,D 把条件写反——链式操作按顺序逐站加工,读代码时从左往右模拟即可。
QUIZ 2
百万元素列表执行 .asSequence().filter{...}.map{...}.first(),相比不加 asSequence 的直接链式调用,关键区别是?
Sequence 惰性求值:first() 触发后一个元素一个元素走完整条链,命中即短路,后面元素不再处理,也没有中间列表。它不并行(A/B/D 都是常见误解);不加 asSequence 则 filter/map 各自遍历全部百万元素并建中间集合。
CHAPTER 06 · Kotlin 进阶机制

扩展函数与作用域函数

一句话总览:扩展函数让你不改源码就给任何类「外挂」新方法(本质是静态函数语法糖);let/run/with/apply/also 五兄弟则是「在对象上下文里干一段活」的标准句式。
🔌
生活化类比
扩展函数像给手机贴外接镜头:手机(原类)没拆没改,功能却多了——但镜头只是「夹上去」的,手机内部电路(private 成员)它碰不到,而且换台手机(多态场景)镜头认的是「你声明时夹的那个型号」(静态解析)。作用域函数像把工具递到师傅手里:apply 是「师傅你自己动手」(this),let 是「师傅看着这件东西加工」(it)。类比边界:外接镜头不会真的变成手机出厂功能——扩展函数不参与继承重写。

6.1 扩展函数:给 String 加个方法

Ext.kt
fun String.isPhone(): Boolean =        // 接收者类型.函数名
    this.length == 11 && this.all { it.isDigit() }   // this = 调用它的那个字符串

println("13800138000".isPhone())       // true,像原生方法一样调用

// 本质:编译成静态函数 ExtKt.isPhone("13800138000")
// 所以:① 访问不了 private 成员 ② 按「声明类型」静态分发,不走多态
open class Base; class Sub : Base()
fun Base.tag() = "base"
fun Sub.tag() = "sub"
val b: Base = Sub()
println(b.tag())                       // "base"!看变量声明类型,不看实际对象

6.2 五个作用域函数:一张表终结选择困难

函数对象在块内叫块返回值典型用途
letitLambda 最后一行判空处理 x?.let{}、转换结果
runthisLambda 最后一行配置对象后算个结果
withthisLambda 最后一行对同一对象连续多次操作(非扩展)
applythis对象自身初始化配置:Intent().apply{}
alsoit对象自身链中顺手打印/校验,不打断链条
Scope.kt
val intent = Intent().apply {          // 配置自身 → 返回自身
    putExtra("id", 1L)                 // this.putExtra,省略 this
    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
}

val len = "kotlin".let { it.length * 2 }   // 转换:返回 Lambda 结果 12

fetchUsers()
    .also { Log.d("API", "拿到 ${it.size} 条") }   // 副作用:日志,链条不断
    .filter { it.age >= 18 }

// 选择口诀:要返回对象本身 → apply(this)/also(it);要返回加工结果 → let(it)/run(this)
扩展函数的真相:静态工具函数 + 语法糖
"138…".isPhone() 你看到的:像 String 的原生方法 ExtKt.isPhone("138…") 编译器做的:静态函数,接收者当第一个参数 编译期改写 推论①:进不了类内部,private 不可见 推论②:按声明类型分发,override 无效
扩展函数没有修改任何类——它只是「第一个参数是接收者」的静态函数,这解释了它的全部能力边界。
⚠ 高频陷阱:作用域函数嵌套后 this/it 迷路
错误写法:user.apply { address.let { name = it } } → 内层 it 是 address,你以为在改 address 的字段,实际 name 解析到了外层 user 的 this 上,静默改错对象。正确姿势:嵌套超过一层就给 Lambda 参数显式命名 address.let { addr -> ... },别省那几个字母。
✓ 记忆口诀
「返回自己:apply 用 this、also 用 it;返回结果:run 用 this、let 用 it;with 不是扩展,对象放括号里。」

6.3 随堂自测

QUIZ 1
父类声明类型 val b: Base = Sub(),Base 和 Sub 各定义了同名扩展函数 tag(),b.tag() 调用的是?
扩展函数编译成静态函数,调用哪个在编译期由「接收者的声明类型」决定,与运行时实际对象无关——它不是成员函数,不参与 override。这是扩展与成员函数最本质的区别。
QUIZ 2
想在构建对象的同时配置它的多个属性,并把「配置好的对象本身」赋给变量,最合适的是?
apply:块内 this 指向对象(属性直接写名),块结束返回对象自身——正是「配置并返回」场景。also 虽返回自身但用 it,配置属性要写 it.x 啰嗦;let/run 返回 Lambda 最后一行的值,容易把配置语句的值误当返回值。
CHAPTER 07 · Kotlin 进阶机制

协程:挂起与结构化并发

一句话总览:协程是「可以暂停再恢复的任务」——挂起时释放线程而不是霸占线程干等;配合作用域(Scope)实现「页面死,任务亡」的结构化并发,这是安卓异步代码的现代标准。
🍜
生活化类比
线程是厨师,协程是订单小票。传统阻塞:厨师守着炖汤的锅站 30 分钟啥也不干(线程 sleep/等待)。协程挂起:厨师把汤放灶上、小票夹到「待恢复」栏,转身去炒别的菜;汤好了再取回小票继续这单。一个厨师(主线程)能同时推进无数张小票(协程)。结构化并发像「餐厅打烊制度」:店(Scope)关门时,所有未完成小票统一作废,不会有厨师半夜还在为已倒闭的店炒菜(内存泄漏)。类比边界:小票恢复时不保证还是原来那个厨师——协程恢复线程由调度器决定(除非限定在主线程调度器)。

7.1 suspend 与 launch:第一个协程

Coroutines.kt
// suspend 标记「此函数可能挂起」,只能在协程或另一个 suspend 函数里调
suspend fun fetchUser(): User {
    delay(1000)                  // 挂起 1 秒:不阻塞线程!线程此刻可以去干别的
    return User(1, "润曦")
}

// ViewModel 中发起协程的标准姿势:
class MyViewModel : ViewModel() {
    fun load() = viewModelScope.launch {     // 作用域绑定 ViewModel,默认主线程
        val user = fetchUser()               // 写法像同步,实际异步挂起
        _state.value = UiState.Success(user) // 回到主线程直接更新状态,安全
    }
}   // ViewModel 销毁 → viewModelScope 自动 cancel → 协程不再回来碰死页面

7.2 调度器与 withContext:换线程不换写法

Dispatchers.kt
viewModelScope.launch {                      // Main:主线程起步
    val data = withContext(Dispatchers.IO) { // 切到 IO 线程池做耗时活
        api.getUsers()                       // 阻塞式网络/数据库调用放这里
    }                                        // 块结束自动切回 Main
    _state.value = data                      // 主线程更新 UI,无需回调
}

// 并行两个请求:async 启动,await 汇合
viewModelScope.launch {
    val a = async { api.getProfile() }       // 两个请求同时发出
    val b = async { api.getOrders() }
    show(a.await(), b.await())               // 总耗时 ≈ max(两者),不是相加
}
调度器线程用途
Dispatchers.Main安卓主线程更新 UI、轻量逻辑
Dispatchers.IO弹性线程池(默认上限 64)网络、磁盘、数据库等阻塞 IO
Dispatchers.DefaultCPU 核数线程池排序、解析大 JSON 等计算密集
HANDS-ON DEMO
协程挂起时间线模拟器
场景:主线程上 launch 一个协程,中途 delay(1000)。逐步点击,观察「协程在等,线程却没闲着」——挂起 ≠ 阻塞的本质区别。
⚠ 高频陷阱:在主线程 runBlocking
错误写法:图省事在主线程写 runBlocking { api.getUsers() } → 后果:runBlocking 会把当前线程钉死等到块结束,主线程被钉 5 秒 → 系统弹 ANR(应用无响应),用户强杀应用。正确姿势:用 viewModelScope.launch;runBlocking 只该出现在单元测试和 main 函数里。另一个兄弟陷阱:GlobalScope.launch 脱离页面生命周期,页面销毁后协程还在跑并持有引用 → 泄漏,一律换成有作用域的 launch。
✓ 记忆口诀
「挂起让线程,阻塞占线程;launch 找作用域,耗时 withContext(IO),并行 async+await。」

7.3 随堂自测

QUIZ 1
主线程上的协程执行到 delay(1000) 这 1 秒内,主线程在干什么?
delay 是挂起而非阻塞:协程保存状态后让出线程,调度器注册一个定时恢复;主线程继续跑消息循环,UI 丝滑。A 描述的是 Thread.sleep——这正是挂起与阻塞的分水岭。
QUIZ 2
页面退出、ViewModel 被销毁时,它 viewModelScope.launch 里还在进行的网络协程会?
结构化并发:协程是 Scope 的孩子,父亡子亡。viewModelScope 在 onCleared 时 cancel,挂起点会抛 CancellationException 正常退栈(被协程机制吞掉,不崩溃)。A/D 正是 GlobalScope 的泄漏行为,也是它被弃用的原因。
CHAPTER 08 · Kotlin 进阶机制

Flow 与 StateFlow

一句话总览:Flow 是「异步的数据流」——冷流(Flow)有人订阅才生产,热流(StateFlow)不管有没有人都在那持着最新值;安卓 UI 状态的现代标准载体是 StateFlow。
📺
生活化类比
冷流是点播视频:每个观众点开都从头独立播一遍,没人看就完全不占带宽(flow{} 里的代码不 collect 就不执行)。StateFlow 是电视台的「当前画面」:不管你开不开电视,它永远播着最新一帧;你随时打开,立刻看到当前值而不是从头回放(所以必须有初始值)。SharedFlow 像电台广播:错过就错过了,默认不重播旧节目。类比边界:电视台信号可以「没人看时停播省电」——stateIn(WhileSubscribed(5000)) 就是干这个的。

8.1 冷流:订阅才开工

ColdFlow.kt
val ticker = flow {                  // flow{} 构建冷流
    println("开始生产")               // 注意:这行此刻不会执行!
    repeat(3) {
        delay(500)
        emit(it)                     // emit:向下游发射一个值
    }
}
// 到这里控制台一片安静——没人 collect,生产者根本没启动

ticker.collect { println("A 收到 $it") }   // 第 1 次订阅:完整跑一遍
ticker.collect { println("B 收到 $it") }   // 第 2 次订阅:再完整跑一遍!

// 操作符与集合类似,但都是挂起的、惰性的
ticker.map { it * 10 }.filter { it > 0 }.collect { println(it) }

8.2 StateFlow:UI 状态的标准容器

StateFlow.kt
class MyViewModel : ViewModel() {
    private val _state = MutableStateFlow(UiState())   // 必须给初始值
    val state: StateFlow<UiState> = _state.asStateFlow()  // 对外只读

    fun refresh() = viewModelScope.launch {
        _state.value = _state.value.copy(loading = true)  // .value 赋值即广播
        _state.value = UiState(api.getUsers())
    }
}

// Compose 界面订阅(生命周期感知:后台自动停止收集)
@Composable fun Screen(vm: MyViewModel = hiltViewModel()) {
    val state by vm.state.collectAsStateWithLifecycle()
    Text("共 ${state.users.size} 人")
}
特性Flow(冷)StateFlow(热)SharedFlow(热)
初始值无必须有可无(replay=0)
无人订阅时不生产持有最新值按 replay 缓存
重复值照常发equals 相等则跳过照常发
典型用途数据库/网络数据管道UI 状态一次性事件(Toast/导航)
冷流 vs 热流:同一份数据,两种分发模型
冷流:每个订阅者触发一条独立生产线 flow{ emit… } A flow{ emit… } B 订阅者 A 订阅者 B 网络请求会执行 2 次! 热流 StateFlow:一条生产线,众人共享最新值 StateFlow.value 永远持有最新一帧 订阅者 A 订阅者 B 晚来的 C 直接拿当前值 stateIn 把冷流转热:上游只跑 1 次
把「每次订阅都请求一次网络」的冷流直接给多个 UI 用是重复请求;stateIn 转成 StateFlow 后大家共享同一条上游。
⚠ 高频陷阱:stateIn 用 SharingStarted.Eagerly 常驻
错误写法:repo.usersFlow().stateIn(scope, SharingStarted.Eagerly, emptyList()) → 后果:App 退到后台,上游数据库监听/轮询永不停止,白耗电白占连接。正确姿势:SharingStarted.WhileSubscribed(5_000)——最后一个订阅者消失 5 秒后停掉上游,转屏这种短暂退订(5 秒内回来)不重启,兼顾省电与体验。
✓ 记忆口诀
「冷流点播、热流直播;状态用 StateFlow(有初值、去重),事件用 SharedFlow(不粘滞)。」

8.3 随堂自测

QUIZ 1
一个 flow{} 冷流内部包裹了网络请求,被两个界面分别 collect,网络请求会执行几次?
冷流「订阅即生产」:每个收集者都从头执行一次生产者代码,两个界面 = 两次请求。想共享一次结果,用 stateIn/shareIn 转热。B 把它当成了 StateFlow,C 忽略了冷流的惰性。
QUIZ 2
StateFlow 当前值为 UiState(a=1),再执行 _state.value = UiState(a=1)(data class,内容完全相同),订阅者会收到新回调吗?
StateFlow 内置 distinctUntilChanged:新旧值 equals 相等就不通知。data class 按属性比较,内容相同即相等。这既是防无效重组的优化,也是「改了 MutableList 内部再赋回旧引用不刷新」这类坑的根源。
CHAPTER 09 · Android 现代工程

工程结构与 Gradle

一句话总览:现代安卓工程用 Kotlin DSL(.kts)写构建脚本 + Version Catalog 统一管版本;理解 compileSdk / minSdk / targetSdk 三个数字各管什么,比背配置模板重要得多。
🏗️
生活化类比
Gradle 是施工总承包:图纸(build.gradle.kts)说要哪些材料(依赖)、按什么标准盖(SDK 版本),它去仓库(Maven 仓库)拉料、按工序施工出成品(APK)。Version Catalog 是全工地统一的材料清单:钢筋型号只写一处,各楼栋(模块)引用同一行,不会出现 A 栋用 3 号钢 B 栋用 5 号钢的惨剧。类比边界:总承包能并行施工多栋楼(多模块并行构建),但同一栋楼的工序(编译→dex→打包)必须按序来。

9.1 一个现代安卓工程长什么样

项目结构
MyApp/
├── settings.gradle.kts          // 声明有哪些模块、从哪些仓库拉依赖
├── gradle/libs.versions.toml    // Version Catalog:全部版本集中在此
├── build.gradle.kts             // 根脚本:声明插件版本,不写业务
└── app/
    ├── build.gradle.kts         // 模块脚本:SDK 版本、依赖、签名
    └── src/main/
        ├── AndroidManifest.xml  // 组件注册、权限声明(App 的户口本)
        ├── java/…               // Kotlin 源码(目录名历史遗留叫 java)
        └── res/                 // 资源:字符串、图标、主题
app/build.gradle.kts(节选)
android {
    compileSdk = 35              // 用哪个版本的 API「编译」:决定你能调用什么
    defaultConfig {
        minSdk = 26              // 最低支持的系统版本:低于它的手机装不上
        targetSdk = 35           // 声明「我按 35 的行为规则测试过」
    }
}
dependencies {
    implementation(libs.androidx.core.ktx)      // 引用 Catalog 里的坐标
    implementation(libs.lifecycle.viewmodel.compose)
    implementation(platform(libs.compose.bom))  // Compose BOM:一套版本对齐全家桶
}
配置回答的问题调低/调高的后果
compileSdk编译时能看见哪些 API太低 → 新 API 编译报错;不影响运行兼容性
minSdk哪些手机能安装调高 → 老手机被拒之门外;调低 → 得处理旧版本兼容
targetSdk系统按哪代规则对待你太低 → 新系统套用兼容旧行为,商店会限期要求升级
implementation依赖只给自己用不向上传递,编译隔离、构建更快(默认首选)
api依赖暴露给依赖我的人传递暴露,改动引发大面积重编译(慎用)
从 Kotlin 源码到 APK 的构建流水线
.kt 源码 + Compose 编译器插件 .class 字节码 Kotlin 编译器产出 JVM 格式 .dex D8/R8 转安卓虚拟机格式 APK 签名打包 dex + res + Manifest Release 时 R8 顺带删无用代码(混淆/瘦身)
Kotlin 先编译成 JVM 字节码再转 dex——所以安卓跑的不是「Kotlin 语言」,而是它编译后的产物;Compose 魔法发生在第一步的编译器插件里。
⚠ 高频陷阱:依赖版本各处手写
错误写法:每个模块的 build.gradle.kts 里手敲 "2.8.7" 之类的版本号 → 后果:升级时漏改一处,运行时 NoSuchMethodError(编译期各模块见的是不同版本的类)。正确姿势:全部版本进 libs.versions.toml,模块只写 libs.xxx 引用;Compose 全家桶用 BOM 对齐,一个字都不手写版本。
✓ 记忆口诀
「compile 管能写啥,min 管谁能装,target 管按啥规矩办;版本进 Catalog,依赖 implementation。」

9.2 随堂自测

QUIZ 1
想调用 API 35 新增的方法,但要求 Android 8(API 26)的手机也能安装,正确配置是?
compileSdk 决定「编译期能看见什么 API」,minSdk 决定「谁能装」,两者独立。老系统上调用新 API 需 Build.VERSION 判断降级处理。A 把两者写反导致老手机装不上;C 的 targetSdk 只管行为规则,不解锁 API。
QUIZ 2
模块 A implementation(retrofit),模块 B 依赖 A。B 的代码里能直接 import retrofit 的类吗?
implementation 把依赖「藏在自己肚子里」,不暴露给上游模块的编译类路径,B 编译期直接报未解析引用。要传递暴露需 A 用 api——代价是 retrofit 一升级,所有依赖 A 的模块全部重编译,所以默认 implementation。
CHAPTER 10 · Android 现代工程

Activity 与生命周期

一句话总览:Activity 是系统托管的「页面外壳」,它的生死不由你 new、不由你删——系统按状态机回调 onCreate→onStart→onResume(进前台)与 onPause→onStop→onDestroy(退后台/销毁),转屏会整只销毁重建。
🎭
生活化类比
Activity 是剧院里的一场演出:onCreate 搭布景、onStart 拉开幕布(可见但还不能互动)、onResume 演员开演(可交互);onPause 暂停互动、onStop 合上幕布、onDestroy 拆台。观众按 Home 键 = 中场休息(戏台还在,随时续演);转屏 = 剧场要求换舞台朝向:整个台拆了照原样重搭。类比边界:重搭时「剧本进度」不该丢——ViewModel 就是坐在台下、不随舞台拆建的导演,进度都在他手里。

10.1 六个回调与两条主干道

MainActivity.kt
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 页面诞生:只做一次性的初始化。savedInstanceState 非 null 说明是重建
        setContent {                    // Compose 时代的 Activity 通常只有这一句
            AppTheme { HomeScreen() }
        }
    }
    override fun onStart()  { super.onStart() }   // 可见了(可能还不可交互)
    override fun onResume() { super.onResume() }  // 到前台,可交互
    override fun onPause()  { super.onPause() }   // 失去焦点(弹对话框/切走)
    override fun onStop()   { super.onStop() }    // 完全不可见(按 Home)
    override fun onDestroy(){ super.onDestroy() } // 销毁:finish 或转屏重建
}
HANDS-ON DEMO
生命周期状态机模拟器
场景:亲手推演一个 Activity 的生死。点「前进」走向前台,点「后退」退向后台,点「旋转屏幕」看整只销毁重建——注意每次日志里回调的成对关系。

10.2 转屏重建:谁死谁活

东西转屏后原因
Activity 对象 / View 树销毁重建系统要按新方向重新加载布局资源
Activity 里的普通字段全部丢失新对象是全新的实例
ViewModel存活存在 ViewModelStore,不随 Activity 重建而清空
Compose remember 的状态丢失随组合销毁;要保过重建用 rememberSaveable
rememberSaveable 的状态存活写入 savedInstanceState 机制随重建恢复
⚠ 高频陷阱:异步回调不管生命周期
错误写法:网络回调里直接 dialog.show() / 更新已销毁页面的 UI → 后果:回调回来时页面可能已 onStop/onDestroy,轻则内存泄漏(回调持有 Activity),重则 IllegalStateException 崩溃。正确姿势:数据放 ViewModel(不怕重建);UI 侧收集数据流用 repeatOnLifecycle(STARTED) 或 Compose 的 collectAsStateWithLifecycle()——后台自动停、前台自动续。
✓ 记忆口诀
「创建—可见—可交互,三级上台;失焦—不可见—销毁,三级下台;转屏拆台重建,进度交给 ViewModel。」

10.3 随堂自测

QUIZ 1
应用在前台,用户按 Home 键回到桌面(进程未被杀),Activity 依次收到?
回桌面 = 完全不可见但未销毁:onPause(失焦)→ onStop(不可见)后停住,实例留着等用户回来(onRestart→onStart→onResume)。onDestroy 只在 finish 或系统回收/配置变更时发生——把 onStop 当 onDestroy 是资源释放时机判断错误的根源。
QUIZ 2
屏幕旋转触发重建后,下列哪组东西还活着?
转屏销毁整个 Activity:实例、字段、View 树、remember 全部重来。ViewModel 存在 ViewModelStore 中跨重建存活;rememberSaveable 借 savedInstanceState 恢复。这套「谁死谁活」正是 MVVM 把状态放 ViewModel 的根本理由。
CHAPTER 11 · Android 现代工程

ViewModel 与单向数据流

一句话总览:现代安卓架构的核心是一条规矩——状态往下流(ViewModel → UI),事件往上走(UI → ViewModel);UI 只负责「照状态画界面 + 把用户操作上报」,一切判断与数据都在 ViewModel。
🍽️
生活化类比
这是餐厅点餐制:顾客(UI)看菜单上的「当前供应」(State)决定看到什么;想吃啥就填单子递给后厨(Event 上报),绝不自己冲进后厨炒菜(UI 不直接改数据)。后厨(ViewModel)做好菜更新供应牌,所有顾客看到的立刻一致。转屏重建 = 顾客换了个座位,但后厨和单子都还在(ViewModel 存活)。类比边界:餐厅只有一个后厨服务一桌客人——ViewModel 是页面级的,不是全 App 共享的全局单例。

11.1 标准三件套:State + Event + ViewModel

HomeViewModel.kt
data class HomeState(                       // ① 状态:一个不可变快照
    val loading: Boolean = false,
    val users: List<User> = emptyList(),
    val error: String? = null
)
class HomeViewModel(private val repo: UserRepo) : ViewModel() {
    private val _state = MutableStateFlow(HomeState())
    val state = _state.asStateFlow()        // ② 对外只读,UI 只能看

    fun onRefresh() {                       // ③ 事件入口:UI 只调这些方法
        viewModelScope.launch {
            _state.update { it.copy(loading = true, error = null) }
            runCatching { repo.loadUsers() }
                .onSuccess { list -> _state.update { it.copy(loading = false, users = list) } }
                .onFailure { e -> _state.update { it.copy(loading = false, error = e.message) } }
        }
    }
}
HomeScreen.kt(UI 侧)
@Composable
fun HomeScreen(vm: HomeViewModel = hiltViewModel()) {
    val state by vm.state.collectAsStateWithLifecycle()   // 状态往下流
    when {
        state.loading -> LoadingView()
        state.error != null -> ErrorView(state.error!!, onRetry = vm::onRefresh)
        else -> UserList(state.users, onRefresh = vm::onRefresh)  // 事件往上走
    }
}   // UI 没有任何业务判断,只是「状态的投影」——可预览、可测试
单向数据流(UDF):一个闭环,两个方向
UI(Compose) 只画状态、只报事件 ViewModel 持有 StateFlow、处理业务 事件上行:onRefresh() / onClick 状态下流:StateFlow<HomeState> Repository(数据来源,第 15 章) ❌ UI 永远不直接改数据、不直接发请求
单向闭环让每个 bug 都能沿「事件→处理→状态→渲染」四站定位;双向乱改(UI 自己改数据)会让状态来源不可追溯。
⚠ 高频陷阱:ViewModel 里存 Activity/View/Compose 引用
错误写法:构造函数传入 Activity 或把 Context(页面的)存成字段 → 后果:ViewModel 比 Activity 命长(转屏时 Activity 死了它还活着),死页面被拽住无法回收,整棵 View 树泄漏。正确姿势:ViewModel 不碰任何 UI 引用;确实需要 Context(如读资源)用 AndroidViewModel 拿 Application Context,或把资源解析留在 UI 层。
✓ 记忆口诀
「状态向下,事件向上;UI 是投影,VM 是大脑;VM 不摸 View,转屏心不慌。」

11.2 随堂自测

QUIZ 1
用户在 Compose 界面点了「刷新」按钮,按 UDF 规矩接下来应该发生什么?
事件上行、状态下行:UI 只上报意图,数据变更全在 ViewModel,界面是状态的自动投影。A/C 让 UI 私改数据,状态出现两个源头;D 是命令式旧时代的做法,Compose 里根本没有 findViewById。
QUIZ 2
为什么规范严禁 ViewModel 持有 Activity 的引用?
转屏时 Activity 销毁重建,而 ViewModel 存活——它若引用旧 Activity,旧实例及其整棵 View 树都无法 GC。这是 LeakCanary 报警榜第一名。需要 Context 时用 Application 级的,它与进程同生命周期,不存在「拖死人」问题。
CHAPTER 12 · Jetpack Compose

Compose 入门:声明式 UI

一句话总览:Compose 的核心思想是 UI = f(state)——你不再「摆控件再手动改控件」,而是描述「状态长这样时界面应该长什么样」,状态一变框架自动重画;Modifier 链则按顺序一层层包装组件。
🖨️
生活化类比
旧 XML 体系像手工雕刻:先雕好一尊像(findViewById),想改表情就自己拿刀补(textView.setText)。Compose 像3D 打印:你只维护模型文件(状态),每次改动后重新打印受影响的部分,从不需要手工修补成品。Modifier 链像套娃包装:先裹泡沫再装箱,和先装箱再裹泡沫,出来的东西完全不同——顺序就是语义。类比边界:3D 打印不会整机重打,Compose 也只重画「读过变化状态」的那一小块(重组,第 13 章)。

12.1 第一个 Composable

Greeting.kt
@Composable                          // 标记:这是「描述 UI」的函数,不是普通函数
fun Greeting(name: String) {
    Column(                          // 纵向排列容器
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        verticalArrangement = Arrangement.spacedBy(8.dp)   // 子项间距
    ) {
        Text(text = "你好,$name", style = MaterialTheme.typography.titleLarge)
        Button(onClick = { /* 事件上报 */ }) {
            Text("点我")              // Button 的内容也是 Composable(槽位 API)
        }
    }
}
// Row 横向、Box 层叠;三者就是 Compose 布局的全部骨架

Composable 函数的特殊之处:它没有返回值,「产出」是向组合树发射 UI 描述;它只能在组合上下文中被调用;它可能被框架反复执行(重组)——所以里面不能写「执行一次就变一次」的副作用(第 14 章讲怎么正确安排副作用)。

12.2 Modifier:顺序即语义

ModifierOrder.kt
// 写法一:先 padding 后 background → 背景不含外边距(四周留白透明)
Text("A", Modifier.padding(16.dp).background(Color.Yellow))

// 写法二:先 background 后 padding → 背景铺满,文字距背景边 16dp
Text("B", Modifier.background(Color.Yellow).padding(16.dp))

// 常用链:尺寸 → 形状/背景 → 内边距 → 点击
Box(Modifier
    .size(80.dp)
    .clip(RoundedCornerShape(12.dp))     // 先裁剪形状
    .background(Color.Cyan)
    .clickable { onClick() }             // clickable 放哪,水波纹范围就在哪层
    .padding(8.dp))
同一串 Modifier,两种顺序,两种结果
padding(16) → background A 背景 外圈 16dp 透明:背景被 padding 挤小了 background → padding(16) B 文字区 背景先铺满,padding 变成「背景内边距」 ≠
Modifier 从左到右是「由外到内」的包装链:每个修饰符作用于「它右边所有东西包完之后」的结果,所以交换顺序=交换语义。
⚠ 高频陷阱:把 clickable 放在 padding 之后
错误写法:Modifier.padding(24.dp).clickable{} 想要大点击区 → 后果:点击热区只剩 padding 里面的小块,外侧 24dp 点了没反应,用户狂点不中。正确姿势:Modifier.clickable{}.padding(24.dp)——clickable 在前,热区覆盖含 padding 的整层。同理,水波纹范围也取决于 clickable 在链中的位置。
✓ 记忆口诀
「UI 是状态的函数;Modifier 由外向内套,谁在左边谁包外面。」

12.3 随堂自测

QUIZ 1
想要「黄色背景铺满整块,文字距背景边缘 16dp」,正确的 Modifier 是?
链由外向内:background 先声明先铺外层,padding 在其内侧形成背景内边距。A 的 padding 在最外层,把背景挤小、四周透明。顺序不是风格问题,是语义本身。
QUIZ 2
关于 @Composable 函数,下列说法正确的是?
Composable 是「UI 描述」,状态变化时被再次执行以刷新描述——执行次数不可假设,发请求/打日志等副作用必须交给 LaunchedEffect 等受控 API。它无返回值、只能在组合上下文调用,B/C/D 都套用了命令式旧观念。
CHAPTER 13 · Jetpack Compose

状态与重组机制

一句话总览:Compose 只认 State(可观察状态):读它的 Composable 会被登记为订阅者,状态一变,只有读过它的那一小块重新执行(重组);普通变量改了框架毫无感知,界面纹丝不动。
🔔
生活化类比
mutableStateOf 是装了门铃的快递柜:谁取过件(读过状态)就自动登记手机号,新件入柜(状态变化)只给登记过的人发短信(精准重组)。普通 var 是没门铃的柜子:东西换了也没人知道。remember 是「重组时别把柜子扔了」——没有它,每次重画都买个新柜子,旧件全丢。类比边界:门铃只通知「读过这个柜子的人」,路过没取过件的邻居(没读该状态的 Composable)不会被吵醒——这就是智能重组。

13.1 remember + mutableStateOf:缺一不可

Counter.kt
@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }   // 标准写法
    // remember:重组时保留这个 State 对象(否则每次都重新归 0)
    // mutableStateOf:可观察,写入自动触发「读过 count 的范围」重组
    // by:属性委托,读写 count 等价于 .value 的读写

    Button(onClick = { count++ }) {               // 写状态 → 触发重组
        Text("点了 $count 次")                     // 读状态 → 登记订阅
    }
}
// 转屏也要保住?换 rememberSaveable { mutableStateOf(0) }
写法重组时保值变化触发重组转屏重建保值
var x = 0❌ 每次归 0❌❌
remember { 普通值 }✓❌ 不可观察❌
mutableStateOf(0)(无 remember)❌✓ 但每次是新对象❌
remember { mutableStateOf(0) }✓✓❌
rememberSaveable { mutableStateOf(0) }✓✓✓
HANDS-ON DEMO
重组模拟器:门铃 vs 没门铃
场景:一个界面含 Header(不读 count)、CounterText(读 count)、Button。分别用「State 状态」和「普通变量」点 +1,观察谁被重组、屏幕值是否跟上真实值。

13.2 智能重组与 derivedStateOf

Smart.kt
@Composable
fun ListScreen(listState: State<List<Item>>) {
    // 高频变化:列表滚动位置每帧都在变
    val showTop by remember {
        derivedStateOf { listState.value.firstVisibleItemIndex > 5 }
    }   // derived:只有「布尔结果」翻转才通知,滚动 1→2→3 不触发重组

    LazyColumn { /* … */ }
    if (showTop) BackToTopButton()   // 只有这里因 showTop 变化而重组
}
// 原则:状态往下传、事件往上传(状态提升),让「读状态的范围」尽量小
⚠ 高频陷阱:状态声明忘了 remember
错误写法:var count = mutableStateOf(0)(没有 remember)→ 后果:每次重组都创建全新 State 并归 0,点击 +1 触发重组 → 重组又把它归 0 → 计数器永远显示 1,看起来像「点了没反应」。正确姿势:remember { mutableStateOf(0) };需要跨转屏再升级 rememberSaveable。
✓ 记忆口诀
「State 带门铃,remember 保存在;谁读谁重组,不读不打扰。」

13.3 随堂自测

QUIZ 1
Composable 里写 var count = 0,按钮 onClick 执行 count++,界面上的数字会?
双重失效:普通 var 不是 State,写入不通知任何人;就算别的原因触发了重组,函数体重新执行又把它初始化为 0。Compose 只追踪 State 的读取,不是「魔法追踪一切变量」。D 描述的是「有 State 没 remember」的另一种坑。
QUIZ 2
Screen 里有 Header()(没读 count)和 CounterText(count)(读了 count),count 状态 +1 后发生什么?
智能重组:Compose 记录「哪个作用域读过哪个状态」,变化只失效对应作用域。没读 count 的 Header(参数也没变)直接跳过。这就是「状态下放、读取范围最小化」能提升性能的机制根源。
CHAPTER 14 · Jetpack Compose

列表、副作用与导航

一句话总览:长列表用 LazyColumn(只组合可见项);「重组之外的世界」(请求、监听、导航)叫副作用,必须交给 LaunchedEffect 等受控 API;页面跳转用 Navigation Compose 的路由表。
🚃
生活化类比
LazyColumn 是地铁车厢:只有乘客所在的几节车厢开灯供空调(可见项才组合),列车再长也不用整列供电。副作用 API 像剧组场记:Composable 是演员,一场戏可能重拍 N 次(重组),「放烟火」这种危险动作(发请求)必须由场记安排「每换一次布景(key 变化)只放一次」,不能让演员每次重拍都随手放。导航像商场导览图:每个店有唯一门牌号(route),逛过的店记在你的足迹栈(back stack)里,按返回就是沿足迹回退。类比边界:车厢驶出视野会断电——LazyColumn 滚出屏幕的项会离开组合,其 remember 状态若无 key 稳定标识就会丢失/串位。

14.1 LazyColumn:给每项一个稳定的 key

UserList.kt
@Composable
fun UserList(users: List<User>, onClick: (User) -> Unit) {
    LazyColumn {                          // 只组合屏幕内 + 少量缓冲项
        items(users, key = { it.id }) { user ->   // key:项的身份证
            UserRow(user, onClick = { onClick(user) })
        }
    }
}
// key 的作用:列表增删/重排时,Compose 靠它认出「谁还是谁」
// 没有 key:按位置认人 → 头部插一条,所有项的勾选态/动画整体错位

14.2 副作用三件套

Effects.kt
@Composable
fun Detail(userId: Long, vm: DetailViewModel) {
    LaunchedEffect(userId) {          // 进入组合时启动协程;userId 变了→取消旧的、重启新的
        vm.load(userId)               // 重组 100 次也不会重复请求(key 没变)
    }
    DisposableEffect(Unit) {          // 需要「善后」的副作用
        val listener = registerListener()
        onDispose { listener.unregister() }   // 离开组合时必执行:反注册防泄漏
    }
    val scope = rememberCoroutineScope()      // 在「事件回调」里启动协程用
    Button(onClick = { scope.launch { snackbar.show("已保存") } }) { Text("保存") }
}
// 铁律:Composable 函数体里不直接发请求/改外部变量——重组次数不可控
API触发时机典型用途
LaunchedEffect(key)进入组合执行;key 变化取消重启加载数据、动画、订阅 Flow
DisposableEffect(key)进入组合注册;离开/key 变化 onDispose监听器注册与反注册
rememberCoroutineScope不自动执行,给事件回调提供 scope点击后弹 Snackbar、滚动

14.3 Navigation:路由表 + 回退栈

AppNav.kt
val nav = rememberNavController()
NavHost(navController = nav, startDestination = "home") {
    composable("home") {
        HomeScreen(onOpen = { id -> nav.navigate("detail/$id") })
    }
    composable("detail/{id}") { entry ->      // 路径参数
        DetailScreen(id = entry.arguments?.getString("id") ?: "")
    }
}
// nav.popBackStack() = 返回上一页;每个目的地有自己的 ViewModel 作用域
LazyColumn 的「可见才组合」与 key 认人
1000 条数据 item 0…7(未组合) item 8…15 可见 只有这些在组合树里 ≈ 一屏的组合开销 item 16…999(未组合) 头部插入新项时,key 决定状态跟谁走 key=id ✓ 状态跟 id 走 无 key ✗ 状态按位置留 插入前:A(勾选) B C 有 key:X A(勾选) B C — 勾选还在 A 无 key:X(勾选) A B C — 勾选串到 X!
Lazy 省的是「组合成本」,key 保的是「身份连续性」——两者合起来才是能上生产的列表。
⚠ 高频陷阱:把请求写进 Composable 函数体
错误写法:@Composable fun Detail(id){ vm.load(id); … } 直接调用加载 → 后果:每次重组都再发一次请求,动画期间一秒请求 60 次,服务端被打爆、界面闪烁。正确姿势:包进 LaunchedEffect(id)——同 key 只执行一次,id 变化才取消旧协程重新加载。
✓ 记忆口诀
「列表 Lazy 加 key;副作用找场记:加载 Launched、注销 Disposable、点击用 scope。」

14.4 随堂自测

QUIZ 1
LaunchedEffect(userId) { vm.load(userId) } 中,界面因无关状态重组了 10 次,userId 一直没变,load 会执行几次?
LaunchedEffect 的契约:进入组合启动一次;之后仅当 key 变化才取消旧协程并重启。无关重组不碰它——这正是「受控副作用」的意义。若把 key 写成 Unit 而 userId 会变,则走向另一个坑:换了用户却不重新加载。
QUIZ 2
万条消息的聊天页,用 Column + verticalScroll 直接放一万个 Row,和 LazyColumn 的本质区别是?
Column+scroll 会组合并测量所有子项,万条数据首帧卡死、内存暴涨;LazyColumn 按需组合、滚出即离组合,成本约等于一屏。B 错在 Column 加 verticalScroll 可以滚,只是不惰性;C 不存在这种机制。
CHAPTER 15 · 数据与工程化

Retrofit 与 Room:数据层

一句话总览:现代数据层的黄金管道是 网络(Retrofit)→ 本地数据库(Room)→ Flow → UI:界面永远只观察数据库这个「单一数据源」,网络只负责往库里灌新数据——离线可看、更新自动推送。
🏪
生活化类比
这是便利店补货模型:顾客(UI)只面对货架(Room 数据库)拿货,从不直接找厂家;采购员(Repository)定期从厂家(服务器 API)进货摆上货架。厂家断供(没网)时货架照样有货可卖(离线缓存);货架一变,价签电子屏(Flow 订阅)自动刷新。Repository 是门店经理:顾客不需要知道货是厂家直送还是仓库调拨——数据来源被封装。类比边界:货架容量有限,真实 App 要设计缓存过期与清理策略,不是无限囤货。

15.1 Retrofit:接口即 API

ApiService.kt
interface UserApi {
    @GET("users")                        // 注解描述 HTTP 请求
    suspend fun getUsers(): List<UserDto>   // suspend:天然配协程
    @GET("users/{id}")
    suspend fun getUser(@Path("id") id: Long): UserDto
}
val api = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())  // JSON ↔ 对象
    .build().create(UserApi::class.java)   // 动态代理生成实现,你只写接口

15.2 Room:让数据库表变成 Kotlin 类

UserDao.kt
@Entity(tableName = "users")             // 类 ↔ 表
data class UserEntity(@PrimaryKey val id: Long, val name: String)

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun observeAll(): Flow<List<UserEntity>>   // 返回 Flow:表一变自动推新列表!

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun upsertAll(users: List<UserEntity>)   // suspend:Room 自动切后台线程
}

// Repository:把「网络刷新」和「本地观察」拼成一条管道
class UserRepo(private val api: UserApi, private val dao: UserDao) {
    fun observeUsers(): Flow<List<UserEntity>> = dao.observeAll()  // UI 只订这个
    suspend fun refresh() {
        dao.upsertAll(api.getUsers().map { it.toEntity() })  // 入库 → Flow 自动推给 UI
    }
}
单一数据源(SSOT):UI 只看数据库,网络只灌数据库
服务器 API Retrofit suspend Repository refresh():拉取→入库 Room 数据库 唯一真相源(货架) UI collect Flow Flow 自动推 用户下拉刷新 → VM → repo.refresh()(事件回路) 断网?货架照常有货
网络结果不直接给 UI,而是先落库再由 Flow 推送——UI 的数据永远只有一个来源,离线、缓存、多页共享全都顺理成章。
⚠ 高频陷阱:在主线程调 Room 的同步查询
错误写法:Dao 方法不加 suspend、不返回 Flow,然后在主线程直接调 dao.getAll() → 后果:Room 默认禁止主线程查询,直接抛 IllegalStateException: Cannot access database on the main thread;有人用 allowMainThreadQueries() 绕过 → 大表查询卡 UI 甚至 ANR。正确姿势:查询声明为 suspend 或返回 Flow,Room 自动调度到后台线程,主线程只管收结果。
✓ 记忆口诀
「UI 盯货架(Room Flow),采购走经理(Repo),厂家(API)只补货不露面。」

15.3 随堂自测

QUIZ 1
Dao 的 @Query 方法返回 Flow<List<UserEntity>>,另一处代码往 users 表插入了一条数据,正在 collect 的界面会?
Room 的 Flow 查询内置「表失效追踪」:任何写入使相关查询失效,Room 在后台重查并把完整新列表推给收集者。这正是 SSOT 架构能「入库即刷新 UI」的机制,不需要任何手动通知。
QUIZ 2
SSOT 架构里,下拉刷新拿到网络数据后,正确的下一步是?
先落库、再观察:保证 UI 数据只有一个来源,离线时依然一致。A/B 制造了「网络版」和「库版」两个真相源,迟早出现界面与缓存不一致;D 的 SP 只适合轻量键值配置,不是结构化列表数据的家。
CHAPTER 16 · 数据与工程化

Hilt、测试与发布

一句话总览:工程的最后一公里:Hilt 自动组装依赖(谁 new 谁的问题交给编译器),测试靠「注入假件」(DI 的最大红利),发布前 R8 瘦身混淆 + 签名——三件事共同把「能跑的 Demo」变成「可维护的产品」。
🧩
生活化类比
没有 DI 时,每个类自己造零件:ViewModel 里 new Repo、Repo 里 new Retrofit——像每个厨师自己养猪种菜,换个供应商全店重写。Hilt 是中央厨房配送体系:你只在构造函数上声明「我要什么料」(@Inject),配送员按图纸自动送货上门;测试时把真食材换成试菜模型(fake),同一套灶具照跑。类比边界:中央厨房的配送单在「开店前」(编译期)就印好校验,缺料直接开不了店(编译报错),不是营业中才发现。

16.1 Hilt:三个注解完成组装

Di.kt
@HiltAndroidApp class MyApp : Application()      // ① 总开关:App 入口

@Module @InstallIn(SingletonComponent::class)    // ② 教 Hilt 造「接口类」的实例
object DataModule {
    @Provides @Singleton
    fun provideApi(): UserApi = Retrofit.Builder().baseUrl(BASE).build().create(UserApi::class.java)
}

class UserRepo @Inject constructor(private val api: UserApi)  // ③ 声明「我需要什么」

@HiltViewModel
class HomeViewModel @Inject constructor(private val repo: UserRepo) : ViewModel()
// Compose 里 hiltViewModel() 一行拿到组装好的实例——全程没有一个手写 new

16.2 测试:DI 让「换假件」成为可能

HomeViewModelTest.kt
class FakeRepo : UserRepo {                      // 假仓库:不发真网络
    override suspend fun loadUsers() = listOf(User(1, "测试"))
}

@Test
fun `刷新成功后状态应为数据`() = runTest {          // runTest:虚拟时钟,delay 秒过
    val vm = HomeViewModel(FakeRepo())           // 注入假件,不碰网络
    vm.onRefresh().join()
    assertEquals(1, vm.state.value.users.size)   // 断言状态
}
// 分层:ViewModel/Repo 用 JVM 单测(快);UI 用 composeTestRule(慢,少量)
层工具跑在哪测什么
ViewModel / RepoJUnit + runTest + fakeJVM(毫秒级)业务逻辑、状态流转
DaoRoom inMemoryDatabase设备/模拟器SQL 正确性、Flow 推送
Compose UIcomposeTestRule设备/模拟器关键交互路径(少量)

16.3 发布:R8 与签名

app/build.gradle.kts(release 节选)
buildTypes {
    release {
        isMinifyEnabled = true       // R8:删未用代码 + 混淆类名 → 包更小更难逆向
        isShrinkResources = true     // 顺带删未引用资源
        proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"),
                      "proguard-rules.pro")   // 反射用到的类要写 keep 规则
    }
}
// 再配好签名 keystore、加 Baseline Profile(预编译热路径,启动提速约 30%)
Hilt 依赖图:声明需求,编译期组装
hiltViewModel() UI 一行领取,不关心怎么造 HomeViewModel @Inject 需要:UserRepo UserRepo @Inject 需要:UserApi @Provides UserApi @Singleton:全 App 一份 缺任何一环 → 编译期报错,不是运行时崩
Hilt 在编译期把整张「谁需要谁」的图连好并校验——运行时只是按图领取;测试时换掉图中一个节点(fake),其余原封不动。
⚠ 高频陷阱:手动 new ViewModel
错误写法:Composable 里 val vm = HomeViewModel(repo) 自己构造 → 后果:绕过了 ViewModelStore,每次重组都造新实例、转屏状态全丢,「ViewModel 抗重建」的机制完全失效。正确姿势:一律 hiltViewModel()(或 viewModel())从 Store 领取——同一页面永远拿到同一只,重建后还是它。
✓ 记忆口诀
「依赖靠声明不靠 new;测试换假件;发布开 R8,反射写 keep;VM 必须领、不能造。」

16.4 随堂自测

QUIZ 1
在 Composable 里写 val vm = HomeViewModel(repo) 而不是 hiltViewModel(),最直接的后果是?
ViewModel 的「抗重建、页面内唯一」来自 ViewModelStore 的存取,不是类本身的魔法。手动 new 出来的只是普通对象:重组即新建、转屏即蒸发。hiltViewModel() 内部走 Store 查找 + 工厂创建,两者缺一不可。
QUIZ 2
release 打开 isMinifyEnabled = true 后,某个靠反射按类名加载的类运行时 ClassNotFoundException,原因是?
R8 靠静态引用分析判断「谁没被用」,反射的字符串类名它看不懂,于是当垃圾删除或混淆改名。解法是在 proguard-rules.pro 里 -keep 住相关类(很多库自带消费规则)。这是「debug 正常、release 崩」的头号原因。
渝ICP备2026024724号-1