02.2 阶段 1:第一门端侧语言(Kotlin 主线)
所属:全栈开发面试题库 / 学习路径 / 02 App 端开发
本页目录
一、阶段定位
阶段 0 解决的是"环境能不能跑起来",本阶段开始真正写代码。为什么第一门端侧语言选 Kotlin:它是 Android 官方推荐语言,语法上吸收了 Java、Swift、Python 的优点,空安全与协程是现代 Android 工程的两块基石;学会 Kotlin 后再看 Swift、Dart、TypeScript 会发现概念高度重合。
本阶段与前后阶段的衔接:往上承接阶段 0 的命令行与调试器,本阶段要真正在 Android Studio 或命令行里写 .kt 文件并编译运行;往下接阶段 2 的 Activity / Fragment 生命周期,那时讨论的不再是"变量怎么声明",而是"这个回调在哪个线程被调用、配置改变后 ViewModel 怎么存状态"。跳过协程直接进阶段 2,后面看到 lifecycleScope.launch { ... } 会完全不知道为什么要 lifecycleScope 而不是 GlobalScope。
原有五段信息里的"卡点"在本阶段要展开成可判断的现象依据:
- 空安全报错靠
!!强行解包绕过:现象是代码里出现大量text!!.text = "xxx",一两个空指针判断就用try/catch包起来。这说明你没有用?.、?:、lateinit、null默认值把空路径在编译期解决,而是把运行时崩溃当兜底。 - 说不清协程作用域与取消规则:现象是被问到"在
lifecycleScope.launch里写一个while(true) Thread.sleep(1000),Activity 销毁后这段代码会怎样"时,答不出"Job 被取消、抛CancellationException、delay会响应取消但Thread.sleep不会"。 - 把 Kotlin 当 Java 写:现象是全程用
var不用val、不写数据类、集合操作全是for循环、不写扩展函数。这说明你只是在"用 Kotlin 的语法写 Java",没享受 Kotlin 的语言红利。
出现以上任一现象,先停在本阶段,不要进入阶段 2。
二、阶段目标与投入
学完本页,应当能用可观察的行为证明以下六条能力:
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能独立写出一个无 !!、无未处理空指针的命令行小工具 |
代码评审时 grep 不到 !!;空路径都有明确处理 |
能解释 val、var、lateinit、by lazy 的区别与使用场景 |
给出一段代码判断哪处该用哪个 |
能用高阶函数与集合操作把一段 for 循环改写成链式调用 |
用 map、filter、groupBy、associateBy 完成等价逻辑 |
能写出一个 suspend 函数并在 lifecycleScope 里调用,说明取消时机 |
旋转屏幕后正在执行的网络请求被取消,日志里能看到 CancellationException |
能用 data class、sealed class 建模一组业务状态 |
写出"加载中/成功/失败"三态,并用 when 穷尽分支 |
能在 build.gradle 里添加一个第三方依赖(如 OkHttp、Gson)并成功同步 |
gradlew build 通过,代码里能 import 该库的类 |
建议学时:
- 全职(每天有效学习 4–6 小时):3–4 周,约 90–110 小时。其中语法与空安全 40%、协程 35%、集合与高阶函数 15%、Gradle 与依赖 10%。协程是难点,时间要给够。
- 在职(每天 2 小时、周末补 4 小时):7–9 周,约 100 小时。按"一个模块一周"的节奏排,不要一次看完全部模块再动手。
学时分配建议:变量与空安全 15%、函数与高阶函数 15%、扩展函数与作用域函数 10%、数据类密封类枚举 10%、集合操作 15%、协程与结构化并发 30%、异常处理与 Gradle 依赖 5%。
三、先修自检
进入本阶段前,逐条自检;任何一条做不到,先回到对应页面补齐。
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 会用命令行与编辑器 | 能在终端里 cd、ls、用编辑器保存 .kt 文件 |
02.1 阶段 0 |
| 知道变量、函数、返回值 | 能写出一个输入两个数返回和的函数 | 02.1 阶段 0 |
| 知道进程与线程基本概念 | 能说出主线程为什么不能做网络请求 | 02.1 阶段 0 |
| Git 基本操作 | 能 git init、git add、git commit |
02.1 阶段 0 |
| Android Studio 能跑 Hello World | 模拟器能启动,App 显示 Hello World | 02.1 阶段 0 |
另有一条经验判断:如果你写过 Java,本阶段最容易犯的错是"把 Kotlin 当 Java 写"——全程 var、不写 data class、Collections.stream() 风格不适应;如果你写过 Python/JS,最容易犯的错是低估空安全的严谨性,看到 String? 就想加 !!。这两类偏差都要在练习里主动纠正。
四、知识地图
"掌握程度"分三档:了解、会用、能讲清原理。本阶段的目标分布如下。
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 变量与类型推断 | val/var、lateinit、by lazy、类型推导 |
会用 | 04.8 Kotlin |
| 空安全 | ?、?.、?:、!!、requireNotNull、lateinit、平台类型 |
能讲清原理 | 04.8 Kotlin |
| 函数与高阶函数 | 默认参数、命名参数、扩展函数、Lambda、it、函数引用 |
会用 | 04.8 Kotlin |
| 作用域函数 | let/run/apply/also/with 的区别与选择 |
会用 | 04.8 Kotlin |
| 类型系统 | data class、sealed class、enum、object、companion object、when 穷尽 |
能讲清原理 | 04.8 Kotlin |
| 集合 | List/MutableList、map/filter/groupBy/associateBy、序列 Sequence |
会用 | 04.8 Kotlin |
| 协程 | suspend、runBlocking、launch、async、Dispatchers、Job、CoroutineScope、结构化并发、CancellationException、Flow 基础 |
能讲清原理 | 04.8 Kotlin |
| 异常与依赖 | try/catch、throw、build.gradle 依赖配置、implementation/api 区别 |
会用 | 04.8 Kotlin |
进度管理建议:把这张表复制到自己的笔记里,每学完一个模块把"掌握程度"往下调一档;三档都到位再进阶段 2。《知识点全清单》是本篇更细的全量清单。
五、分模块精讲
5.1 变量、类型推断与空安全
为什么需要它:Kotlin 的空安全是编译期特性,目的是把 Java 时代 NullPointerException 这种运行时崩溃前移到编译期。不懂 ?、?.、?:、!! 的区别,就会要么到处 !! 把空安全废掉,要么过度设计 ? 让代码读起来累。
核心机制:
val是只读(对应 Java 的final),var是可变。默认用val,确需重新赋值才用var。- 类型系统分两类:非空类型
String与可空类型String?。String不能赋null,String?可以。 ?.是安全调用:name?.length在name为 null 时返回 null,不继续求值。?:是 Elvis 运算符:name?.length ?: 0在name为 null 时取默认值 0。!!是强解包:name!!.length在name为 null 时直接抛NullPointerException。这是把编译期问题推迟到运行时,能不用就不用。lateinit var用于"我知道这个变量稍后会被初始化,但现在没法给值"的场景(如 Android 注入、onCreate里findViewById)。访问前未初始化会抛UninitializedPropertyAccessException。by lazy是惰性初始化:第一次访问时才执行 lambda,之后缓存结果。线程安全默认是LazyThreadSafetyMode.SYNCHRONIZED。- 平台类型
String!来自 Java 互操作:Kotlin 不知道 Java 方法返回值是否可能为 null,按可空处理,要自己判断。
最小可运行示例:
fun main() {
val name: String = "ann" // 非空,不能赋 null
var nick: String? = null // 可空
// 安全调用 + Elvis
println(nick?.length ?: 0) // 0
// let:只在非空时执行块
nick?.let { println("nick is $it") }
// 故意制造 NPE(仅演示)
// println(nick!!.length) // 抛 NullPointerException
}
class User {
// lateinit:框架注入场景,不能用 val
lateinit var token: String
fun init(t: String) { token = t }
fun printToken() { println(token) } // 未 init 就调用会抛 UninitializedPropertyAccessException
}
val config by lazy {
println("loading...") // 第一次访问才打印
mapOf("timeout" to 3000)
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
代码里全是 !! |
不熟悉 ?.、?:,图省事 |
用 ?: 给默认值;用 ?.let { } 包裹空路径 |
UninitializedPropertyAccessException: lateinit property xxx has not been initialized |
访问前没给值 | 用 ::xxx.isInitialized 判断,或改用构造函数注入 |
println(config) 每次都打印 "loading..." |
用了 var config = loadConfig() 而不是 by lazy |
改 val config by lazy { ... } |
| Java 调用方传了 null,Kotlin 这边没判 | 平台类型 String! 编译期不报错 |
在 Kotlin 入口用 requireNotNull 或 ?: error("...") 显式拦截 |
面试考法:"String 和 String? 的区别""lateinit 和 by lazy 的区别""Kotlin 的空安全怎么实现的"。答题要点:编译期类型系统区分;lateinit 是 var 可延迟赋值,by lazy 是 val 首次访问才初始化;空安全不是靠运行时检查,而是靠类型系统在编译期禁止把 null 赋给非空变量。
5.2 函数、高阶函数与 Lambda
为什么需要它:Kotlin 的 API 设计大量依赖高阶函数——list.filter { it > 0 }、view.setOnClickListener { ... }、coroutineScope { ... }。不懂 Lambda 与 it 隐式参数,读代码会处处卡壳。
核心机制:
- 函数参数默认值:
fun greet(name: String = "guest"),调用时可省略。 - 命名参数:
greet(name = "ann"),多个参数时可读性更好。 - Lambda 是函数字面量:
{ x: Int, y: Int -> x + y },最后一行是返回值。 - Lambda 作为函数最后一个参数时可以移到括号外:
list.forEach { println(it) }。 it是单个参数 Lambda 的隐式名,仅在参数唯一时可用。- 函数引用:
::println是(Any?) -> Unit的引用,可作为高阶函数参数传入。 - 扩展函数:
fun String.shout() = this.uppercase() + "!",调用方式name.shout(),但它本质是静态方法,不能被子类重写。
最小可运行示例:
fun greet(name: String = "guest", prefix: String = "Hello") = "$prefix, $name"
fun main() {
println(greet()) // Hello, guest
println(greet("ann", "Hi")) // Hi, ann
println(greet(prefix = "Hey", name = "bob")) // Hey, bob(命名参数)
// Lambda:平方
val square = { x: Int -> x * x }
println(square(5)) // 25
// 高阶函数:对列表每个元素做变换
val nums = listOf(1, 2, 3, 4)
println(nums.map { it * 2 }) // [2, 4, 6, 8]
println(nums.filter { it % 2 == 0 }) // [2, 4]
}
// 扩展函数:给 String 加一个方法
fun String.shout() = this.uppercase() + "!"
fun main() {
println("hello".shout()) // HELLO!
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
Lambda 里写了 it 但报错 |
参数多于一个,没有隐式 it |
显式命名参数:{ a, b -> a + b } |
| 扩展函数"没生效" | 在错误的包里没 import | import com.example.shout |
| 函数默认值和 Java 调用方不兼容 | Java 看不到默认参数 | 加 @JvmOverloads,生成多个重载 |
| Lambda 捕获了外部变量,线程间出现竞态 | Lambda 闭包引用了可变变量 | 用不可变 val;确需共享用并发容器 |
面试考法:"Lambda 里 it 是什么""扩展函数能被重写吗""高阶函数和普通函数的区别"。答题要点:it 是单参数 Lambda 的隐式名;扩展函数是静态分派,不能被子类重写;高阶函数是接收函数作为参数或返回函数的函数。
5.3 作用域函数:let / run / apply / also / with
为什么需要它:这五个函数是 Kotlin 最常用但最容易混淆的 API。它们都用来"在某个对象的作用域内执行一段代码",但返回值、this 与 it 的指向不同。
核心机制:
let:参数是it,返回 lambda 最后一行。常用于空安全转换:user?.let { ... }。run:参数是this,返回 lambda 最后一行。常用于"在对象上做计算并返回结果"。apply:参数是this,返回对象本身。常用于"配置对象":TextView().apply { text = "x"; textSize = 14f }。also:参数是it,返回对象本身。常用于"链式调用中插入副作用":list.map { ... }.also { println(it.size) }.filter { ... }。with:不是扩展函数,接收对象作为参数,块内this指向该对象,返回最后一行。
选择口诀:需要"配置对象"用 apply;需要"空路径执行块"用 let;需要"在对象上算个值返回"用 run;需要"链中插日志"用 also。
最小可运行示例:
data class User(var name: String, var age: Int)
fun main() {
// apply:配置对象,返回对象本身
val u = User("ann", 18).apply {
age = 20 // this.age = 20
println("configuring $name")
}
// let:非空才执行
val maybeUser: User? = u
maybeUser?.let {
println("name is ${it.name}")
}
// run:在对象上算值
val ageNextYear = u.run { age + 1 }
println(ageNextYear) // 21
// also:链中插副作用
val names = listOf("a", "b", "c")
.also { println("原始 size: ${it.size}") }
.map { it.uppercase() }
.also { println("大写后: $it") }
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
apply 里改了对象但返回的还是旧值 |
把 apply 当 run 用,期待返回 lambda 结果 |
apply 返回对象本身;要返回值用 run 或 let |
let 块里 it 和外部变量重名 |
外部也有 it 或命名冲突 |
显式命名:let { user -> ... } |
| 嵌套作用域函数导致可读性差 | 套了三层 let/apply |
抽成命名函数;不要为了"用作用域函数"而用 |
with 在 null 接收者上报错 |
with 不是扩展函数,接收者必须非空 |
用 ?.let { ... } 或 run { ... } |
面试考法:"apply 和 run 的区别""什么时候用 let"。答题要点:apply 返回对象本身用于配置,run 返回 lambda 结果用于计算;let 配合 ?. 做非空执行。
5.4 数据类、密封类与 when 穷尽
为什么需要它:Kotlin 用 data class 一行代码替代 Java 的 POJO + getter/setter/equals/hashCode/toString;用 sealed class 建模"有限种状态",配合 when 编译器能强制你处理所有分支。这是现代 Android UI 状态管理的基础。
核心机制:
data class User(val name: String, val age: Int)自动生成equals、hashCode、toString、copy、componentN(解构)。copy用于不可变对象的局部修改:u.copy(age = 20)。sealed class是"受限继承":子类必须定义在同一文件(或同一模块的 Kotlin 1.5+)。表示"这个类型只有这几种可能"。enum class是"固定个实例",sealed class是"固定种子类"。前者每个实例是单例,后者每个子类可以有多个实例。when配合sealed class做穷尽判断:不写else,编译器会检查是否所有子类都处理了。漏一个就编译错误。object是单例:object Database整个 JVM 只有一个实例。companion object是类级静态成员,对应 Java 的static。
最小可运行示例:
data class User(val name: String, val age: Int)
sealed class UiState {
object Loading : UiState() // 单例对象
data class Success(val data: List<String>) : UiState()
data class Error(val message: String) : UiState()
}
fun render(state: UiState): String = when (state) {
UiState.Loading -> "加载中..."
is UiState.Success -> "成功,共 ${state.data.size} 条"
is UiState.Error -> "失败: ${state.message}"
// 不需要 else:sealed 保证穷尽,漏一个子类编译报错
}
fun main() {
val u = User("ann", 18)
val older = u.copy(age = 20)
println(u) // User(name=ann, age=18)
println(older) // User(name=ann, age=20)
println(render(UiState.Loading))
println(render(UiState.Success(listOf("a", "b"))))
println(render(UiState.Error("网络错误")))
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
data class 的 equals 没按预期工作 |
类里有可变 var 字段参与 equals |
优先用 val;确需可变字段用 @EqualsAndHashCode(onlyExplicitlyIncluded = true) |
when 里漏了一个分支但没报错 |
用了普通 class 而不是 sealed class |
改成 sealed class,编译器会强制穷尽 |
data class 里有非构造函数参数 |
data class 的 equals 只认主构造参数 |
额外字段不参与相等性,或不用 data class |
object 在 Android 里持有 Context 导致内存泄漏 |
单例生命周期与 App 一样长,持有 Activity 会让它无法回收 | 单例里只存 Application Context;不要存 Activity/View |
面试考法:"data class 自动生成哪些方法""sealed class 和 enum 的区别""when 怎么做到穷尽检查"。答题要点:data class 生成 equals/hashCode/toString/copy/componentN;sealed class 限制子类在同模块,when 不需要 else;enum 是固定实例,sealed 是固定子类。
5.5 集合操作与 Sequence
为什么需要它:Android 列表数据处理(过滤、映射、分组、排序)几乎全靠集合操作。不理解 map/filter 是中间操作还是末端操作、什么时候该用 Sequence,就会写出一堆 for 循环或过度创建中间 List。
核心机制:
List是只读,MutableList是可变。Kotlin 默认listOf()返回不可变 List。- 中间操作(
map、filter、sorted)返回新 List,每一步都创建一个中间集合。 - 末端操作(
toList、count、first)触发整个计算。 Sequence是惰性的:每个元素流水线式走完所有中间操作,不创建中间集合。大数据量或长链路时性能更好。- 常用操作:
map(变换)、filter(过滤)、groupBy(分组)、associateBy(按 key 转 Map)、flatMap(扁平化)、distinct(去重)、sortedBy(排序)。
最小可运行示例:
data class Order(val id: Int, val userId: Int, val amount: Double)
fun main() {
val orders = listOf(
Order(1, 100, 99.9),
Order(2, 100, 50.0),
Order(3, 200, 200.0),
Order(4, 100, 30.0),
)
// 链式:筛选 userId=100,按金额排序,取 id 列表
val ids = orders
.filter { it.userId == 100 }
.sortedByDescending { it.amount }
.map { it.id }
println(ids) // [1, 2, 4]
// 按用户分组
val byUser = orders.groupBy { it.userId }
println(byUser[100]?.size) // 3
// Sequence:10 万元素时不创建中间集合
val big = (1..100_000).asSequence()
.filter { it % 2 == 0 }
.map { it * 2 }
.take(10)
.toList()
println(big)
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
大数据量下 map/filter 链内存暴涨 |
每步创建中间 List | 用 asSequence() 改惰性求值 |
listOf 返回的列表不能 add |
Kotlin 默认不可变 | 用 mutableListOf() 或 arrayListOf() |
groupBy 后取单个元素还要 ?.first() |
用 associateBy 直接转 Map |
orders.associateBy { it.id } 得到 Map<Int, Order> |
map 里做了 IO 操作,性能差 |
集合操作默认同步在当前线程 | IO 切协程;不要在 map 里做网络请求 |
面试考法:"map 和 flatMap 的区别""什么时候用 Sequence"。答题要点:map 一对一变换,flatMap 一对多然后扁平化;Sequence 惰性求值,大数据量或多步操作时避免中间集合。
5.6 协程与结构化并发
为什么需要它:这是 Kotlin 与 Android 现代工程的核心。从阶段 3 的 lifecycleScope.launch 到阶段 6 的启动优化,异步代码全靠协程。不懂 suspend、Dispatchers、Job、取消规则,看到 viewModelScope.launch { ... } 就只会复制粘贴。
核心机制:
suspend标记函数是可暂停函数,只能在协程或另一个suspend函数里调用。它不阻塞线程,而是"挂起"当前协程,线程可以去做别的事。runBlocking是桥接函数:阻塞当前线程直到内部协程完成。只在 main 函数或测试里用,不要在 Android UI 里用。CoroutineScope管理一组协程:launch返回Job,async返回Deferred。scope.cancel()取消所有子协程。- 结构化并发:子协程继承父协程的
CoroutineContext;父协程会等待所有子协程完成;父协程取消会传播到所有子协程。 Dispatchers:Main(主线程,UI 操作)、IO(IO 密集,线程池)、Default(CPU 密集)、Unconfined(不切线程,少用)。- 取消是协作式的:
delay()会响应取消抛CancellationException;但Thread.sleep()或纯 CPU 循环不会自动响应,要定期检查isActive。 async { }.await()返回结果;async块内抛异常会在await时重新抛出。CoroutineExceptionHandler用于捕获未处理异常。
最小可运行示例:
import kotlinx.coroutines.*
suspend fun fetchUser(): String {
delay(1000) // 模拟网络请求,不阻塞线程
return "ann"
}
suspend fun fetchOrders(): List<String> {
delay(800)
return listOf("order1", "order2")
}
fun main() = runBlocking {
// launch:不返回结果
val job = launch(Dispatchers.IO) {
repeat(10) {
println("tick $it")
delay(200)
}
}
// async:并行请求,await 取结果
val userDeferred = async { fetchUser() }
val ordersDeferred = async { fetchOrders() }
val user = userDeferred.await()
val orders = ordersDeferred.await()
println("user=$user, orders=$orders")
delay(500)
job.cancel() // 取消,子协程抛 CancellationException
println("job cancelled")
}
// Android 中:在 ViewModel 里用 viewModelScope
class MyViewModel : ViewModel() {
fun load() {
viewModelScope.launch(Dispatchers.IO) {
val data = fetchUser() // IO 线程
withContext(Dispatchers.Main) {
// 更新 UI(主线程)
println(data)
}
}
// ViewModel 销毁时 viewModelScope 自动 cancel,不需要手动管理
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
GlobalScope.launch { ... } 在 Activity 销毁后还在跑 |
GlobalScope 不与任何生命周期绑定 | 用 lifecycleScope / viewModelScope,销毁自动取消 |
Thread.sleep(1000) 在协程里不响应取消 |
取消是协作式的,sleep 不检查取消 | 改用 delay(1000);或循环里检查 isActive |
async { }.await() 抛异常但没被 catch |
异常在 await 时抛出 | 用 try/catch 包 await;或 CoroutineExceptionHandler |
| 子协程抛异常,父协程也跟着取消 | 结构化并发:一个子失败会取消整个作用域 | 用 supervisorScope 隔离失败,或 async(Job()) 独立 |
| 在主线程做了 1 秒计算,UI 卡顿 | 没切 Dispatchers.Default |
withContext(Dispatchers.Default) { ... } |
面试考法:"协程和线程的区别""suspend 函数会不会阻塞线程""launch 和 async 的区别""为什么不能用 GlobalScope"。答题要点:suspend 是挂起不是阻塞,线程释放出来做别的;launch 不返回结果,async 返回 Deferred;GlobalScope 不受结构化并发管理,Activity 销毁后泄漏。
5.7 Gradle 依赖与异常处理
为什么需要它:Android 工程的第三方库(OkHttp、Retrofit、Gson、Coil)都在 build.gradle 里声明。不懂 implementation 和 api 的区别、不知道依赖冲突怎么查,同步时一片红就只能"删了重下"。
核心机制:
app/build.gradle里dependencies { ... }块声明依赖。implementation:依赖只对当前模块可见,其他模块不能直接用,编译更快。api:依赖会传递给依赖当前模块的模块,类似 Java 的compile。一般只有库模块才用。coreLibraryDesugaring:Java 8+ API 在低版本 Android 上的兼容。- 异常:
try { ... } catch (e: Exception) { ... } finally { ... },Kotlin 异常是 unchecked。 throw IllegalArgumentException("xxx")抛异常;require(value > 0) { "must be positive" }抛IllegalArgumentException;check(value != null) { "must not be null" }抛IllegalStateException。
最小可运行示例:
// app/build.gradle.kts
dependencies {
implementation("com.squareup.okhttp3:okhttp:4.12.0")
implementation("com.squareup.retrofit2:retrofit:2.11.0")
implementation("com.squareup.retrofit2:converter-gson:2.11.0")
implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.0")
}
fun divide(a: Int, b: Int): Int {
require(b != 0) { "divisor must not be zero" } // 参数校验
return a / b
}
fun main() {
try {
println(divide(10, 0))
} catch (e: IllegalArgumentException) {
println("error: ${e.message}")
} finally {
println("done")
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
同步时报 Conflict with dependency ... |
多个库依赖同一库的不同版本 | 在 app/build.gradle 里强制指定版本 |
implementation 的库在其他模块 import 不到 |
implementation 不传递 |
库模块改用 api,或在需要的模块重新声明 |
NullPointerException 在 catch 里抓不到 |
NPE 是 RuntimeException,catch Exception 能抓到;catch Throwable 更宽 |
用 catch (e: Exception) |
require 和 check 的区别 |
不熟悉 | require 校验参数抛 IllegalArgumentException,check 校验状态抛 IllegalStateException |
面试考法:"implementation 和 api 的区别""require 和 check 的区别"。答题要点:implementation 不传递,编译快;api 传递,库模块用;require 校验参数,check 校验对象状态。
六、分层练习
6.1 复现型(照着做,目标是"跑通 + 能解释")
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 写一个命令行待办清单 | 用 data class 建模 Todo,支持添加、列出、完成 |
代码无 !!;空路径用 ?: |
2 小时 |
| 复现 NPE 与安全调用 | 故意写 null!!.length,再改成 ?.let |
看到 NullPointerException 后能解释如何避免 |
0.5 小时 |
| 用集合操作处理订单数据 | 按 5.5 的示例,完成分组、排序、过滤 | 不写 for 循环,全链式 | 1 小时 |
| 协程并行请求 | 用 async 同时请求两个接口,await 取结果 |
日志里能看到两个请求并行耗时约等于最长的那个 | 2 小时 |
| 复现取消 | 在 launch 里 while(true) delay(100),500ms 后 cancel |
日志里出现 CancellationException,循环停止 |
1 小时 |
6.2 改造型(给出现成代码,改出正确行为)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
消除所有 !! |
给定一段到处 !! 的代码 |
改用 ?.、?:、lateinit、requireNotNull |
1 小时 |
| 把 for 循环改集合操作 | 给定一段 for (item in list) { if (...) ... } |
用 map/filter/groupBy 等价改写 |
1 小时 |
把 GlobalScope 改成结构化 |
给定 GlobalScope.launch 代码 |
改为在 coroutineScope { } 或自定义 CoroutineScope |
1 小时 |
| 用 sealed class 建模 UI 状态 | 给定一个用 String 表示状态的代码 |
改成 sealed class UiState,when 穷尽 |
2 小时 |
用 apply 配置对象 |
给定一堆 val u = User(); u.name = "x"; u.age = 18 |
改成 User().apply { ... } |
0.5 小时 |
6.3 设计型(自己定方案,目标是"能交付、能讲清取舍")
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 本地文件统计工具 | 扫描一个目录,统计每种文件类型的大小与数量 | 用 data class 建模;空目录、权限拒绝有明确处理 |
4 小时 |
| 通用 Result 类型 | 设计 sealed class Result<out T> 含 Success/Failure/Loading |
能在 ViewModel 里用 when 穷尽处理三态 |
2 小时 |
| 协程网络请求封装 | 写一个 safeCall { ... } 高阶函数,统一 try/catch 与 Dispatcher 切换 |
业务调用方只写业务逻辑,不写 try/catch | 3 小时 |
| 集合性能对比 | 对比 List 链操作与 Sequence 在 100 万元素上的耗时 |
有数据表格,能解释差异原因 | 2 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
NullPointerException: null |
用了 !! 或 Java 互操作传了 null |
看堆栈定位行号 | 用 ?./?:;入口用 requireNotNull |
UninitializedPropertyAccessException: lateinit property xxx has not been initialized |
访问 lateinit 前没赋值 | 检查初始化时机 | 用 ::xxx.isInitialized 判断;改构造注入 |
NetworkOnMainThreadException 在协程里还出现 |
launch(Dispatchers.Main) 里直接发网络请求 |
看协程上下文 | 切 Dispatchers.IO:withContext(Dispatchers.IO) { ... } |
| 协程不响应取消 | 用了 Thread.sleep 或纯 CPU 循环 |
看日志是否抛 CancellationException |
改 delay;循环里 yield() 或检查 isActive |
ClassCastException 在 when 里 |
when 用了普通 if/else 没穷尽 |
改 sealed class | 漏分支编译报错,补全 |
同步报 Could not resolve com.squareup.okhttp3:okhttp:4.12.0 |
仓库没配或网络问题 | ./gradlew build --info 看请求 URL |
在 settings.gradle 配 mavenCentral 或阿里云镜像 |
Data class equals 不符合预期 |
含可变字段 | 检查字段 | 用 val;或 @EqualsAndHashCode(onlyExplicitlyIncluded = true) |
Lambda 里 it 报错 |
参数多于一个 | 看 Lambda 参数个数 | 显式命名参数 |
八、出口条件
全部勾选后再进入 阶段 2 Android 平台基础与 UI。
- [ ] 代码里 grep 不到
!!,空路径都有明确处理 - [ ] 能说清
val/var/lateinit/by lazy的区别与使用场景 - [ ] 能用
data class与sealed class建模业务状态,when穷尽 - [ ] 能用集合操作把一段
for循环改写成链式调用,知道何时用Sequence - [ ] 能写出
suspend函数,解释Dispatchers.Main/IO/Default的选择 - [ ] 能解释结构化并发:父取消如何传播到子、
CancellationException何时抛出 - [ ] 能在
build.gradle里加依赖并说明implementation与api的区别 - [ ] 排障表里的八个现象,随机抽三个能在 5 分钟内给出排查路径
自测题(先自己想,再看要点):
String和String?在运行时有区别吗?- 要点:运行时没有区别,都是
java.lang.String;区别在编译期类型系统,禁止把 null 赋给非空类型。
- 要点:运行时没有区别,都是
lateinit var和by lazy的区别?- 要点:lateinit 是 var 可延迟赋值,用于框架注入;by lazy 是 val 首次访问才初始化,线程安全。
launch和async的区别?- 要点:launch 返回 Job 不返回结果;async 返回 Deferred,await 取结果,块内异常在 await 时抛出。
- 为什么不能用
GlobalScope?- 要点:不受结构化并发管理,Activity 销毁后协程仍在跑,泄漏;用 lifecycleScope / viewModelScope。
sealed class和enum class的区别?- 要点:enum 是固定个单例实例;sealed 是固定种子类,每个子类可有多个实例。
delay(1000)和Thread.sleep(1000)在协程里的区别?- 要点:delay 是 suspend 函数,挂起不阻塞线程,响应取消;sleep 阻塞线程,不响应取消。
implementation和api的区别?- 要点:implementation 不传递,编译快;api 传递给依赖方,库模块用。