罗罗编程学习记录
本页内容 展开查看

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 分钟内给出排查路径

自测题(先自己想,再看要点):

  1. String 和 String? 在运行时有区别吗?
    • 要点:运行时没有区别,都是 java.lang.String;区别在编译期类型系统,禁止把 null 赋给非空类型。
  2. lateinit var 和 by lazy 的区别?
    • 要点:lateinit 是 var 可延迟赋值,用于框架注入;by lazy 是 val 首次访问才初始化,线程安全。
  3. launch 和 async 的区别?
    • 要点:launch 返回 Job 不返回结果;async 返回 Deferred,await 取结果,块内异常在 await 时抛出。
  4. 为什么不能用 GlobalScope?
    • 要点:不受结构化并发管理,Activity 销毁后协程仍在跑,泄漏;用 lifecycleScope / viewModelScope。
  5. sealed class 和 enum class 的区别?
    • 要点:enum 是固定个单例实例;sealed 是固定种子类,每个子类可有多个实例。
  6. delay(1000) 和 Thread.sleep(1000) 在协程里的区别?
    • 要点:delay 是 suspend 函数,挂起不阻塞线程,响应取消;sleep 阻塞线程,不响应取消。
  7. implementation 和 api 的区别?
    • 要点:implementation 不传递,编译快;api 传递给依赖方,库模块用。