04.8.1.3 泛型、扩展、inline 与 DSL
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.8 Kotlin / 04.8.1 语言核心与类型系统
本节要解决的问题
本节覆盖 Kotlin 泛型型变与擦除、reified 实参、扩展函数与接收者、inline 内联与 noinline/crossinline、编译器契约,以及 DSL 构建器、@DslMarker、操作符与中缀约定。版本基线为 Kotlin 2.x、JDK 17+;版本行为不确定处标注「待确认」并给出验证点。
04.8.1.3-001 Kotlin 泛型可以声明在哪些位置?
一句话结论
泛型可声明在类、接口、函数与属性上:泛型类/接口绑定类型参数,泛型函数在函数签名声明局部类型参数,泛型属性通过 getter/setter 携带类型参数。
概念解释
类型参数用尖括号声明,作用域限定在对应声明内。泛型函数的类型参数只对该函数有效,不依赖类级参数;属性泛型较少见,主要用于派生属性类型。
原理流程
- 类名后声明
<T>,类体与构造器使用 T。 - 函数名前声明
<T>,参数与返回类型引用 T。 - 属性声明类型参数并在访问器类型中使用。
- 调用/实例化时传入实参或由编译器推断。
代码或图示
class Box<T>(val value: T)
fun <T> identity(x: T): T = x
val <T> List<T>.secondOrNull: T?
get() = if (size >= 2) this[1] else null
常见误区
- 把函数级类型参数写到类名后:作用域不匹配。
- 泛型属性类型参数与类参数重名造成遮蔽。
追问
- 答:泛型函数类型参数何时确定?答:调用时由实参或目标类型推断,也可显式指定。
- 答:接口泛型与类泛型规则一致吗?答:一致,接口同样声明类型参数并参与型变。
04.8.1.3-002 泛型在 JVM 上的类型擦除如何表现?
一句话结论
编译到 JVM 后泛型实参被擦除为上界(默认 Object),运行时容器只保留原始类型;List<String> 与 List<Int> 在运行时是同一类对象。
概念解释
擦除是 JVM 历史兼容机制:字节码不保存类型实参信息。编译器在编译期做类型检查,插入必要的强转;运行时无法仅凭容器区分泛型实参。
原理流程
- 编译期按泛型签名检查类型兼容。
- 字节码中类型参数替换为上界类型。
- 取值点插入类型转换指令。
- 反射与
is判断只能看到擦除后的外层类型。
代码或图示
val a: List<String> = listOf("x")
val b: List<Int> = listOf(1)
// 运行时 a 与 b 均为擦除后的 List;无法用 is List<String> 区分
常见误区
- 运行时用
is List<String>做判断:编译受限。 - 以为泛型信息保存在类对象上:类对象只有外层类型。
追问
- 答:擦除后如何携带类型标记?答:reified 内联函数在编译期传入
T::class,或在数据结构中保存类型令牌。 - 答:数组为什么保留元素类型?答:JVM 数组在创建时记录组件类型,与泛型容器擦除规则不同。
04.8.1.3-003 为什么需要型变(in/out)?
一句话结论
型变描述泛型类型之间的子类型关系:List<Dog> 能否替换 List<Animal> 取决于容器是只产出值还是只消费值;out 协变、in 逆变解决赋值兼容问题。
概念解释
不带型变的泛型是不变的:List<Dog> 不是 List<Animal>。若接口只把 T 作为返回值(生产者),可以协变;只把 T 作为参数(消费者),可以逆变。
原理流程
- 分析类型参数在接口中的位置:返回位置还是参数位置。
- 生产者用
out T,允许子类型实参替换。 - 消费者用
in T,允许父类型实参替换。 - 同时读写则保持不变。
代码或图示
interface Producer<out T> { fun get(): T }
interface Consumer<in T> { fun accept(item: T) }
常见误区
- 给同时读写的接口标
out:写入方法会破坏协变安全。 - 把型变理解为运行时行为:它是编译期子类型规则。
追问
- 答:不标型变的默认状态?答:不变,泛型类型之间不构成子类型关系。
- 答:型变检查在哪个阶段?答:编译期类型检查,违反约束报错。
04.8.1.3-004 协变 out 适用于什么生产者场景?
一句话结论
out T 表示类型参数只从接口产出(返回值位置),Producer<Dog> 可赋值给 Producer<Animal>;接口内部不能把 out T 作为写入参数。
概念解释
协变沿子类型方向放宽:返回 Dog 的对象可以当作返回 Animal 的对象使用。标准库只读集合 List<out E> 就是协变生产者,元素只被读取不被修改。
原理流程
- 接口方法中 T 只出现在返回类型。
- 声明
out T后编译器禁止 T 出现在消费参数位置。 - 子类型实参可替换父类型实参。
- 赋值与传参按协变规则兼容。
代码或图示
interface Source<out T> {
fun next(): T
}
val strings: Source<String> = object : Source<String> { override fun next() = "x" }
val animals: Source<Any> = strings
常见误区
- 在
out接口里声明fun add(item: T):编译报错。 - 以为
out后外部也不能修改返回值:外部按返回类型使用,约束在接口内部。
追问
- 答:
List<out E>为什么是协变?答:只读接口只产出元素,没有写入消费位置。 - 答:协变返回类型与方法重写有何联系?答:重写返回位置允许子类型,与协变方向一致。
04.8.1.3-005 逆变 in 适用于什么消费者场景?
一句话结论
in T 表示类型参数只被接口消费(参数位置),Consumer<Animal> 可赋值给 Consumer<Dog>;接口内部不能把 in T 作为返回值产出。
概念解释
逆变沿反方向放宽:能接受 Animal 的消费者,当然能接受 Dog。函数类型 (T) -> Unit 的参数位置就是逆变位置。
原理流程
- 接口方法中 T 只出现在参数类型。
- 声明
in T,编译器禁止 T 作为返回值。 - 父类型实参可替换子类型实参。
- 调用方传入子类型实参被消费接口接受。
代码或图示
interface Sink<in T> { fun send(item: T) }
val animalSink: Sink<Animal> = object : Sink<Animal> { override fun send(item: Animal) {} }
val dogSink: Sink<Dog> = animalSink
常见误区
- 在
in接口返回T:违反逆变约束。 - 把消费者集合误标
out:写入方法不兼容协变。
追问
- 答:比较器
Comparator<in T>为什么逆变?答:它消费两个 T 做比较,不产出 T。 - 答:逆变与方法参数兼容规则?答:参数接受父类型更宽,与逆变方向一致。
04.8.1.3-006 不变类型有哪些约束?
一句话结论
不标 in/out 的泛型类型是不变的:Box<Dog> 与 Box<Animal> 互不兼容,即使内部类型有子类型关系;接口同时读写 T 时必须保持不变。
概念解释
不变是最严格的默认状态:既不能把子类型实参向上替换,也不能向下替换。可变集合 MutableList<T> 同时读取与写入,因此是不变的。
原理流程
- 类型参数同时出现在读写位置。
- 编译器不允许声明型变。
- 赋值检查要求实参类型完全匹配。
- 需要协变/逆变时拆分只读与可变接口。
代码或图示
class Holder<T>(var value: T)
// Holder<Dog> 不能赋给 Holder<Animal>,反之亦然
val mut: MutableList<String> = mutableListOf()
// MutableList<Any> 与 MutableList<String> 不兼容
常见误区
- 期待可变集合像只读集合一样协变:写入位置破坏协变安全。
- 强行给读写接口加
out/in:编译约束报错。
追问
- 答:标准库如何区分只读与可变型变?答:
List<out E>协变只读,MutableList<T>不变可变。 - 答:不变类型能否使用星投影?答:可以,星投影表达未知实参的安全使用视图。
04.8.1.3-007 声明点型变与使用点型变有什么区别?
一句话结论
Kotlin 使用声明点型变:在泛型类/接口声明处标 in/out,整个接口的子类型规则确定;Java 使用通配符在使用点逐处声明 ? extends/? super。
概念解释
声明点型变让类型定义一次,调用方自动获得兼容关系;使用点型变在每个变量/参数位置临时放宽。Kotlin 也支持使用点投影(星投影与类型投影),但核心型变在声明处表达。
原理流程
- Kotlin 接口声明
Producer<out T>。 - 所有使用点自动按协变规则判断兼容。
- Java 方法签名用
List<? extends T>临时协变。 - 互操作时 Java 通配符映射为 Kotlin 投影类型。
代码或图示
// Kotlin 声明点
interface Readable<out T> { fun read(): T }
// 对比 Java 使用点:List<? extends Animal>
常见误区
- 把 Java 通配符习惯直接套到 Kotlin 声明上:型变位置不同。
- 以为 Kotlin 没有使用点投影:局部投影与星投影仍是使用点机制。
追问
- 答:Java
? extends T对应 Kotlin 什么?答:协变投影,近似out T位置表达。 - 答:声明点型变的收益?答:调用方无需重复声明,类型关系在接口定义处统一审查。
04.8.1.3-008 星投影 * 的语义与安全边界是什么?
一句话结论
星投影表示「泛型实参未知」:把 MutableList<*> 当作只读安全视图,不能向其中写入任意值,读取得到上界类型;它是处理未知实参的安全退路。
概念解释
* 等价于带上下界的投影:产出位置按上界读取,消费位置禁止写入具体值。星投影不改变擦除事实,只是在编译期提供安全使用边界。
原理流程
- 编译器把
*展开为带边界的类型投影。 - 读取元素:返回上界类型(如
Any?)。 - 写入元素:实参未知,禁止传入具体值。
- 需要精确类型时通过 reified 或类型令牌恢复。
代码或图示
fun printAll(items: List<*>) {
items.forEach { println(it) } // it: Any?
}
val unknown: MutableList<*> = mutableListOf(1, "x")
// unknown.add("y") // 写入受限
常见误区
- 以为星投影能保留具体实参:运行时仍擦除。
- 向
MutableList<*>写入值:编译受限。
追问
- 答:
List<*>与List<Any?>区别?答:前者实参未知且写入受限;后者明确元素可空为 Any?,读写按该类型。 - 答:星投影读取元素类型是什么?答:类型参数上界,默认
Any?。
04.8.1.3-009 星投影与泛型上下界是什么关系?
一句话结论
星投影按类型参数的上下界展开:* 读取侧取上界类型,写入侧对应下界;声明了 T : Number 的容器,星投影读取为 Number。
概念解释
上下界约束决定未知实参的安全可见类型。没有显式上界时默认 Any?;有类上界时读取位置按该上界暴露。星投影不绕过界约束。
原理流程
- 查看类型参数声明的上界。
- 星投影读取位置映射为上界类型。
- 写入位置按未知实参禁止具体写入。
- 下界约束(
in位置)参与投影展开规则。
代码或图示
class Container<T : Number>
fun inspect(c: Container<*>) { /* 读取侧按 Number 边界理解 */ }
常见误区
- 忽略显式上界,把星投影元素当作
Any?:有界时应为上界类型。 - 在星投影上调用需要精确实参的方法:类型不足。
追问
- 答:如何从星投影恢复具体类型?答:运行时保存类型令牌,或用 reified 内联函数在编译期携带实参。
- 答:星投影能否用于函数返回类型?答:可以,但调用方只能按边界类型使用。
04.8.1.3-010 泛型上界与多界约束如何声明?
一句话结论
类型参数后用 : 类型 声明上界,如 T : Comparable<T>;多个上界按语言规则组合,约束 T 必须同时满足所有边界类型。
概念解释
上界限定实参范围:要求 T 实现某接口、继承某类。递归上界 T : Comparable<T> 表达「自身可与自身比较」。多界约束让类型同时满足类与接口要求。
原理流程
- 类型参数声明后接冒号与上界类型。
- 实参必须是上界类型的子类型。
- 函数体内可按上界类型调用成员。
- 多个边界按语法组合声明。
代码或图示
fun <T : Comparable<T>> max(a: T, b: T): T = if (a >= b) a else b
fun <T> sort(items: List<T>) where T : Comparable<T>, T : Any {
// ...
}
常见误区
- 上界写具体类型却在函数内调用不存在的成员:需按上界接口方法调用。
- 多界约束语法位置写错:编译报错。
追问
- 答:F-bounded 递归约束是什么?答:
T : Self<T>形式,类型参数引用自身,常见于 Comparable 与链式 builder。 - 答:上界为类与接口混合怎么写?答:按多界约束规则组合,具体语法以官方文档为准。
04.8.1.3-011 可空上界 T : Any? 与 T : Any 有什么区别?
一句话结论
默认上界 Any? 允许可空实参;声明 T : Any 要求实参非空,函数体内 T 可按非空类型使用。
概念解释
上界可空性决定类型参数在函数内的空安全状态。需要调用 T 的成员而不判空时,把上界收紧为 Any;宽松工具函数保留默认 Any?。
原理流程
- 未写上界:
T : Any?,实参可空。 - 显式
T : Any:实参必须非空。 - 函数体内按上界可空性做安全检查。
- 传入可空实参给
Any上界类型编译报错。
代码或图示
fun <T : Any> requireNonNull(x: T?): T = x ?: throw IllegalArgumentException()
fun <T> loose(items: List<T>) { /* T 可为可空 */ }
常见误区
- 以为
List<T>元素天然非空:默认上界允许可空实参。 - 在
Any?上界内直接解引用 T:需要判空。
追问
- 答:上界
Any与类型后缀T?关系?答:上界约束类型参数本身;T?是使用点可空标注,两层独立。 - 答:泛型实参可空性如何检查?答:编译期结合上界与实参类型后缀判断。
04.8.1.3-012 递归类型约束(F-bounded)是什么?
一句话结论
类型参数引用自身作为上界,如 T : Comparable<T> 或 T : Builder<T>,约束实现类型「与自身同类可比较/可链式返回自身」。
概念解释
F-bounded 让基类/接口访问派生类型自身。常见于比较器、链式 builder 与枚举自类型场景;编译器据此在基类方法中返回或接受派生类型。
原理流程
- 声明
T : SelfInterface<T>。 - 实参传入派生类型自身。
- 基类方法可按 T 类型返回或比较。
- 不满足递归约束的实参被拒绝。
代码或图示
abstract class Builder<T : Builder<T>> {
abstract fun self(): T
fun name(v: String): T { /* 配置后返回 self() */ return self() }
}
常见误区
- 派生类未把自身作为实参传入:链式返回类型不正确。
- 递归约束写成循环类继承:类型参数不是类继承。
追问
- 答:
Comparable<T>为什么是递归约束?答:实现类用自身类型实例化,比较方法接受同类型参数。 - 答:F-bounded 与普通上界区别?答:上界类型表达式中引用了类型参数自身。
04.8.1.3-013 泛型实参如何推断与显式指定?
一句话结论
编译器从实参类型、目标返回类型与上下文推断类型实参;推断不足或需要明确时,在调用处用尖括号显式指定类型实参。
概念解释
推断顺序结合参数表达式类型与目标位置类型。公共泛型 API 常显式写实参以保证签名可读;局部调用依赖推断即可。
原理流程
- 收集各实参表达式候选类型。
- 结合返回值目标类型收窄。
- 唯一候选则确定实参。
- 歧义或不足时显式
<T>指定。
代码或图示
fun <T> emptyList(): List<T> = listOf()
val strings = emptyList<String>() // 显式指定
val inferred: List<Int> = emptyList() // 目标类型推断
常见误区
- 目标类型缺失时依赖推断:实参可能停留在
Nothing?。 - 公共 API 不显式实参:调用方阅读签名困难。
追问
- 答:构造泛型类时实参如何推断?答:按构造参数类型与目标变量类型推断。
- 答:推断失败的常见原因?答:无目标类型、参数类型不统一、类型参数未出现在签名中。
04.8.1.3-014 运行时类型不可得为什么需要 reified?
一句话结论
普通泛型擦除后运行时拿不到 T 的类对象,无法做 is T 判断或查类;reified 配合 inline 在编译期把实参带入函数,运行时可访问 T::class。
概念解释
擦除限制了反射、序列化、类型判断等运行时需求。reified 类型参数由内联机制保留:函数体在调用点展开,实参类型随编译期上下文进入。
原理流程
- 普通泛型:字节码擦除 T,运行时无类对象。
- 声明
inline fun <reified T>。 - 编译期记录实参类型,函数体展开到调用点。
- 函数内可访问
T::class做类型判断与反射。
代码或图示
inline fun <reified T> isInstance(v: Any): Boolean = v is T
inline fun <reified T> className(): String = T::class.java.name
常见误区
- 在非 inline 函数声明
reified:编译报错。 - 以为 reified 改变了 JVM 擦除规则:它是编译期内联保留,不是运行时泛型容器保存实参。
追问
- 答:reified 能用于类类型参数吗?答:不能,仅限 inline 函数;类参数仍受擦除限制。
- 答:
T::class返回什么?答:KClass,可通过.java取 JVM Class。
04.8.1.3-015 inline fun + reified T 的编译机制是什么?
一句话结论
inline 函数体在编译期展开到每个调用点,reified 实参类型作为编译期信息保留到展开后的代码中,因此函数内可引用 T::class 与做 is T 判断。
概念解释
内联消除了函数调用边界,类型参数不再经过运行时擦除传递。编译器把实参类型写进展开代码,运行时判断基于具体类型完成。
原理流程
- 编译器识别 inline 函数与 reified 参数。
- 每个调用点替换为函数体代码。
- reified 实参类型在展开处确定并保留。
- 函数内
T::class、is T编译为具体类型操作。
代码或图示
inline fun <reified T> List<Any>.filterIsInstance(): List<T> =
filter { it is T }.map { it as T }
常见误区
- 把 reified 当作运行时类型参数传递:实际是编译期展开保留。
- 内联函数递归调用:inline 受限,见后续题目。
追问
- 答:reified 函数能否返回
Class<T>?答:可返回T::class.java,类型在展开点确定。 - 答:内联展开对字节码体积的影响?答:每个调用点复制函数体,调用点多时代码膨胀。
04.8.1.3-016 reified 有哪些使用限制?
一句话结论
reified 只能用于 inline 函数的类型参数,不能用于类属性、非 inline 方法或普通委托;受内联展开位置与编译期可见性约束。
概念解释
reified 依赖内联机制保留类型,离开 inline 上下文无编译期类型可携带。类级泛型、接口方法与普通工具类方法不能声明 reified。
原理流程
- 检查函数是否
inline:否则拒绝 reified。 - reified 参数只在该函数体作用域可用。
- 不能把 reified 类型参数存入运行时泛型容器做擦除后判断。
- 跨内联边界传递受编译器规则限制。
代码或图示
// 非法:非 inline 不能 reified
// fun <reified T> bad(): T = TODO()
// 合法:inline 内使用
inline fun <reified T> tag() = T::class.simpleName
常见误区
- 尝试在伴生对象方法上用 reified:非 inline 场景不允许。
- 把 reified T 当作可序列化类型令牌长期保存:展开点之外不可用。
追问
- 答:需要在普通类中保存类型怎么办?答:显式传入
KClass<T>或Class<T>作为构造/方法参数。 - 答:reified 与泛型实参推断冲突时谁优先?答:显式实参优先,否则按内联上下文推断。
04.8.1.3-017 reified 在反序列化与类型判断中有哪些典型应用?
一句话结论
reified 用于按类型过滤集合、获取类对象、绑定反序列化结果类型等场景,避免手动传递 Class 对象,调用处写法更简洁。
概念解释
典型场景:filterIsInstance 一类类型过滤、JSON 库的 reified 扩展、事件总线按类型订阅。底层仍是编译期类型携带,运行时做具体类型匹配。
原理流程
- 调用处传入目标类型(显式或推断)。
- 内联展开保留 T。
- 函数内
is T/T::class做判断与反射。 - 结果按 T 类型返回,减少外部强转。
代码或图示
inline fun <reified T> Any?.asTypeOrNull(): T? = this as? T
// 集合类型过滤
val numbers: List<Number> = listOf(1, 2L, 3.0)
val ints = numbers.filterIsInstance<Int>()
常见误区
- 用 reified 做深层泛型实参判断:擦除后仍无法区分
List<String>与List<Int>。 - 反序列化库 reified 扩展不检查库版本支持:需实测。
追问
- 答:reified 能否判断泛型容器元素类型?答:不能,擦除后元素类型不可得。
- 答:JSON 反序列化 reified 扩展写法以什么为准?答:所用库官方文档与版本,不确定处标注待确认。
04.8.1.3-018 擦除后 is T 编译报错时的替代方案是什么?
一句话结论
非 reified 泛型内 is T 因擦除无法检查而报错;替代方案是显式传入 KClass/Class 做 isInstance,或改用 reified 内联函数。
概念解释
编译器知道运行时无法拿到 T,因此直接拒绝类型判断。需要运行时类型校验时,由调用方提供类型令牌,函数通过反射 API 判断实例归属。
原理流程
- 普通泛型函数内写
is T:编译报错。 - 方案一:参数接收
KClass<T>,调用isInstance。 - 方案二:函数改 inline + reified,编译期保留类型。
- 反射判断结果按令牌类型返回。
代码或图示
fun <T> filter(list: List<Any>, type: KClass<T>): List<T> =
list.filter { type.isInstance(it) }.map { @Suppress("UNCHECKED_CAST") it as T }
inline fun <reified T> filterReified(list: List<Any>): List<T> =
list.filter { it is T }.map { it as T }
常见误区
- 绕过编译检查用未检查强转:类型不安全,需配合令牌校验。
- 以为传
Class后就能检查泛型实参:外层类型可判,元素类型仍擦除。
追问
- 答:
KClass.isInstance对应 Java 什么?答:Class.isInstance,运行时判断对象归属。 - 答:未检查强转告警如何处理?答:在校验后使用,按编译器抑制规则标注并说明安全前提。
04.8.1.3-019 容器擦除后 List<String> 与 List<Int> 的运行时身份是什么?
一句话结论
两者运行时都是擦除后的 List,类对象相同,hashCode/反射不区分元素类型;只在编译期签名上有类型差异。
概念解释
泛型信息不写入 JVM 类对象。把容器赋值给星投影或原始类型后,无法通过运行时 API 判断原本元素实参。序列化与持久化需另外保存元素类型。
原理流程
- 编译后容器元素类型擦除。
- 类对象为原始 List 类型。
- 反射读取不到类型实参。
- 需要元素类型时由数据结构显式保存令牌。
代码或图示
val strs = listOf("a")
val ints = listOf(1)
// strs::class == ints::class(擦除后同为 List 表示)
常见误区
- 运行时比较两个 List 的泛型类型:不可得。
- 序列化依赖容器泛型自动恢复元素类型:库需显式处理。
追问
- 答:数组为什么不擦除?答:JVM 数组创建时记录组件类型,与泛型容器机制不同。
- 答:Jackson 一类库如何恢复泛型?答:通过类型令牌/泛型序列化器显式携带,而非依赖擦除后容器。
04.8.1.3-020 泛型函数与 SAM 转换如何配合?
一句话结论
泛型函数接收函数类型参数时,lambda 实参可按目标函数类型推断;传给 Java SAM 接口时触发 SAM 转换,泛型实参同时约束接口实现类型。
概念解释
类型参数贯穿函数签名、函数类型与 SAM 接口。lambda 参数类型由目标泛型签名推断;Java 单方法接口在互操作边界适配为函数调用。
原理流程
- 泛型函数声明函数类型参数
(T) -> Unit。 - 调用 lambda,编译器按 T 推断参数类型。
- Java SAM 接口场景生成接口实现实例。
- 泛型实参在接口实现上保持约束。
代码或图示
fun <T> consume(item: T, action: (T) -> Unit) = action(item)
consume("hello") { println(it.length) }
常见误区
- lambda 参数类型与泛型实参不匹配:编译推断报错。
- 以为 Kotlin 接口也走 SAM 转换:Kotlin 函数类型优先,SAM 支持范围以版本为准。
追问
- 答:函数类型本身型变如何标注?答:参数位置逆变、返回位置协变,见后续函数类型型变题。
- 答:泛型实参缺失时 lambda 类型如何推断?答:需目标类型或显式实参补足。
04.8.1.3-021 扩展函数的声明结构是什么?
一句话结论
扩展函数在普通函数前声明接收者类型:接收者类型.函数名(参数),函数体内通过 this 访问接收者实例;它不修改原类,只是在调用点提供语法糖。
概念解释
扩展用于为已有类型补充工具方法,无需继承或改造源码。声明包含接收者类型、函数名、参数列表与函数体;可声明为顶层、类内或局部扩展。
原理流程
- 写
fun Receiver.method(args): ReturnType。 - 函数体内
this绑定接收者实例。 - 编译为静态函数,第一个参数为接收者。
- 调用点
receiver.method(args)语法转发。
代码或图示
fun String.hasPrefix(): Boolean = this.startsWith("kotlin")
val s = "kotlin-lang"
println(s.hasPrefix())
常见误区
- 以为扩展会向原类写入方法:原类字节码不变。
- 扩展访问接收者私有成员:扩展只能访问公开/可见成员。
追问
- 答:扩展函数可以是顶层的吗?答:可以,顶层扩展编译到文件包装类。
- 答:局部扩展作用域?答:只在声明它的函数/块内可见。
04.8.1.3-022 扩展函数为什么是静态解析,不参与多态?
一句话结论
扩展在编译期按接收者声明类型解析,不是虚方法分发;接收者实际类型替换不会改变调用的扩展版本,因此不能通过扩展覆写父类方法。
概念解释
扩展不是类成员,没有进入虚方法表。编译期根据变量/表达式的静态类型选择扩展函数;运行时对象替换不触发多态分派。同名成员方法优先于扩展。
原理流程
- 编译期识别接收者静态类型。
- 查找该类型可见的扩展函数。
- 生成静态调用,传入接收者参数。
- 运行时不按实际类型重新选择扩展。
代码或图示
open class Animal
class Dog : Animal()
fun Animal.greet() = "animal"
fun Dog.greet() = "dog"
val a: Animal = Dog()
println(a.greet()) // 按静态类型 Animal 解析,输出 animal
常见误区
- 期待扩展像成员方法一样被子类重写:静态解析不支持。
- 用扩展实现多态策略:应使用接口与类继承。
追问
- 答:成员方法与扩展同名谁优先?答:成员方法优先,扩展作为补充。
- 答:扩展能否被
open覆盖?答:不能,扩展不是可重写成员。
04.8.1.3-023 扩展属性有哪些规则与限制?
一句话结论
扩展属性在接收者类型上声明属性语法,但不能存储幕后字段;必须提供 getter,可变扩展属性需 getter/setter,值由接收者状态派生。
概念解释
扩展属性是访问器语法糖,没有独立存储。不能初始化字段,不能直接持有状态;常用于派生只读字段,如集合派生属性。
原理流程
- 声明
val Receiver.prop: Type get() = ...。 - 编译器生成静态访问器方法。
- 每次访问从接收者状态计算。
- 可变扩展属性 setter 也转发为静态方法。
代码或图示
val String.lastChar: Char
get() = this[this.length - 1]
val "kotlin".lastChar
常见误区
- 给扩展属性赋初始值:无幕后字段,不允许。
- 期望扩展属性保存跨调用状态:状态应放在原类或包装类。
追问
- 答:扩展属性可以有 setter 吗?答:可以,声明
var并实现 get/set,set 内修改接收者可见状态。 - 答:扩展属性与委托属性冲突吗?答:可组合,但委托状态仍不存储在扩展属性字段中。
04.8.1.3-024 顶层扩展与成员方法的优先级如何解析?
一句话结论
同名调用时成员方法优先于扩展函数;扩展按接收者类型可见性与导入顺序解析,多个候选冲突时编译器要求显式消歧。
概念解释
成员属于类本身,解析优先级最高。扩展是外部补充,在成员缺失时参与候选。导入不同包的同名扩展可能造成歧义,需要限定调用或调整导入。
原理流程
- 先检查接收者类型是否有同名成员方法。
- 成员存在:调用成员方法。
- 成员缺失:查找可见扩展函数。
- 多扩展候选:按类型匹配度与规则选择,歧义时报错。
代码或图示
class ListHolder {
fun size() = 10 // 成员优先
}
fun ListHolder.size(): Int = 20 // 扩展不覆盖成员
常见误区
- 定义扩展试图覆盖已有成员:不会生效。
- 导入多个同名扩展导致调用歧义:按诊断限定接收者或导入。
追问
- 答:扩展函数可见性由什么控制?答:声明可见性与导入作用域,未导入不可见。
- 答:同类型多个扩展谁生效?答:匹配更具体的类型优先,歧义由编译器报错提示。
04.8.1.3-025 如何定义允许空接收者的扩展函数?
一句话结论
把接收者类型声明为可空 Receiver?,函数体内自行判空处理;非空接收者扩展不能在 null 上调用。
概念解释
标准库 orEmpty 一类扩展即空接收者扩展。声明接收者 T? 后,函数内 this 可能为空,需要 ?. 或判空分支。
原理流程
- 扩展声明接收者为
T?。 - 函数体读取可空
this。 - 为空时返回缺省值或处理分支。
- 调用方可在可空变量上直接调用该扩展。
代码或图示
fun String?.orBlank(): String = this ?: ""
val name: String? = null
println(name.orBlank())
常见误区
- 在非空接收者扩展内直接解引用可空值:接收者类型不匹配。
- 空接收者扩展不判空:函数体内触发空安全报错。
追问
- 答:空接收者扩展与安全调用
?.关系?答:扩展内部处理空值,调用处可省略?.;非空扩展仍需安全调用。 - 答:标准库哪些扩展允许空接收者?答:
orEmpty、集合判空扩展等,按标准库文档核对。
04.8.1.3-026 扩展函数中接收者类型与 this 如何指向?
一句话结论
扩展函数体内 this 绑定接收者实例,类型为声明的接收者类型;在类内部扩展时,可能同时存在调度接收者与扩展接收者两个 this。
概念解释
普通函数 this 指向所在类实例;扩展函数的 this 指向被扩展对象。类内声明的扩展,外层类实例与扩展接收者需要用限定 this 消歧。
原理流程
- 顶层扩展:
this即接收者类型实例。 - 类内扩展:外层类为调度接收者,扩展类型为扩展接收者。
- 同名歧义时用
this@Outer与this@Receiver限定。 - 编译为静态函数,接收者作为首参传入。
代码或图示
class Context {
fun String.format(): String {
val outer = this@Context
return "[$this] in ${outer.label()}"
}
fun label() = "ctx"
}
常见误区
- 混淆两个接收者
this:成员解析到错误对象。 - 扩展内访问调度接收者私有成员:受可见性规则限制。
追问
- 答:扩展接收者与调度接收者术语是什么?答:extension receiver 与 dispatch receiver,两个
this并存。 - 答:顶层扩展有几个接收者?答:只有扩展接收者。
04.8.1.3-027 调度接收者与扩展接收者如何区分?
一句话结论
类内扩展函数中,调度接收者是声明扩展的外层类实例,扩展接收者是被扩展类型实例;二者通过 this@类名 显式区分。
概念解释
当扩展写在类体内时,函数同时属于外层类上下文与扩展类型上下文。解析成员时按两个接收者顺序查找,同名成员必须限定来源,避免歧义。
原理流程
- 外层类实例为调度接收者。
- 扩展类型实例为扩展接收者。
- 成员查找先匹配最近接收者。
- 冲突时用限定语法指定
this@调度类/扩展接收者。
代码或图示
class Dialog {
fun Button.enable() {
this.isEnabled = true // 扩展接收者 Button
this@Dialog.title = "ok" // 调度接收者 Dialog
}
}
常见误区
- 不写限定导致访问到错误接收者成员。
- 把类内扩展当作顶层扩展复用:接收者上下文不同。
追问
- 答:DslMarker 与双接收者有关吗?答:DSL 多层接收者场景用标记限制外层隐式访问,见后续 DSL 题目。
- 答:两个接收者类型可以相同吗?答:同名类型时更需限定
this来源。
04.8.1.3-028 扩展函数的可见性与导入如何控制?
一句话结论
顶层扩展按文件可见性声明,调用方需导入对应包或文件;类内扩展仅在类作用域可见,局部扩展只在声明块内可见。
概念解释
扩展不是全局自动可见,依赖导入与作用域控制。可见性规则与普通函数一致:public 导入可见,private/internal 限定边界。
原理流程
- 声明扩展时指定可见性修饰符。
- 顶层扩展在对应包内,调用方导入后使用。
- 类内扩展随外层类作用域。
- 未导入或越界不可见,编译报错。
代码或图示
// utils/Strings.kt
internal fun String.trimAll(): String = this.replace(" ", "")
常见误区
- 以为标准库扩展随处可用:自定义扩展需导入。
- 把跨模块内部扩展暴露给外部:
internal边界受限。
追问
- 答:扩展可以
private声明在文件内吗?答:可以,文件内私有辅助扩展。 - 答:Java 侧能否看到 Kotlin 顶层扩展?答:编译为静态工具方法,按文件包装类访问,不是接收者类型成员。
04.8.1.3-029 泛型扩展与类型约束如何结合?
一句话结论
扩展函数可声明类型参数与上界,接收者类型也可参数化,如 List<T>.firstOrNull();约束决定扩展内可调用的接收者成员。
概念解释
泛型扩展兼顾复用与类型安全:接收者是泛型容器时,扩展内按类型参数边界访问元素。标准库大量集合扩展属于泛型扩展。
原理流程
- 扩展声明类型参数与接收者泛型类型。
- 上界约束元素可用成员。
- 函数体按泛型类型操作。
- 调用处推断实参类型。
代码或图示
fun <T : Comparable<T>> List<T>.maxOrNull(): T? =
if (isEmpty()) null else max()
fun <T> List<T>.second(): T = this[1]
常见误区
- 上界不足却在扩展内调用边界外成员:编译报错。
- 泛型扩展接收者写死具体类型:失去复用价值。
追问
- 答:泛型扩展与泛型成员方法区别?答:扩展是外部静态函数,成员属于类类型层级。
- 答:扩展能否带 reified 实参?答:可以,inline 扩展函数声明 reified 参数。
04.8.1.3-030 标准库扩展函数在生态中处于什么定位?
一句话结论
标准库通过扩展为集合、字符串、序列等类型补充链式操作(map/filter/let/run 等),在不改造核心类型的前提下提供丰富 API,是 Kotlin 惯用风格的基础。
概念解释
扩展让标准库保持核心类型精简,工具方法以扩展形式分布。链式调用与作用域函数构成 Kotlin 代码的典型可读性特征;理解扩展机制才能区分标准库方法与自定义工具。
原理流程
- 核心类型保持基础实现。
- 扩展函数按场景补充操作。
- 调用方链式组合多个扩展。
- 编译期静态解析为对应静态调用。
代码或图示
val result = listOf(1, 2, 3)
.filter { it > 1 }
.map { it * 2 }
.firstOrNull()
常见误区
- 把标准库扩展当作原类自带方法记录源码结构:原类未写入这些方法。
- 链式过长不拆分:可读性与调试性下降。
追问
- 答:作用域函数也是扩展吗?答:
let/run/apply/also等是标准库顶层/扩展函数,详见集合与互操作章节。 - 答:自定义扩展应放哪里?答:按领域聚合到工具文件,导入后复用,避免散落在业务类内。
04.8.1.3-031 扩展不能被覆写的典型案例是什么?
一句话结论
子类重写父类成员时,同名扩展不会被覆盖;按静态类型解析的扩展调用固定绑定声明类型,多态行为必须通过接口/继承实现。
概念解释
案例:父类与子类各有同名扩展,变量声明为父类时调用父类扩展,即使实际是子类实例。这与成员方法虚分派行为不同,是扩展静态解析的直接后果。
原理流程
- 定义开放父类与子类。
- 分别为两者写同名扩展。
- 父类型变量持有子类实例。
- 编译期按父类型解析扩展,运行时不切换。
代码或图示
open class Expr
class Num : Expr()
fun Expr.eval(): Int = 0
fun Num.eval(): Int = 42
val e: Expr = Num()
println(e.eval()) // 0,静态解析为 Expr 扩展
常见误区
- 用扩展做策略多态:应改为接口方法。
- 调试时困惑「实际类型为何没走子类扩展」:静态解析机制所致。
追问
- 答:成员方法为何能多态?答:成员进入虚方法表,运行时按实际类型分派。
- 答:需要按实际类型分发怎么办?答:在类层级定义开放成员,或使用 sealed + when 分派。
04.8.1.3-032 成员函数与扩展同名时的解析规则是什么?
一句话结论
成员方法优先:接收者类型存在同名成员时调用成员,扩展不参与覆盖;扩展只在成员缺失时成为候选。
概念解释
解析顺序保证类自身定义的行为不被外部扩展篡改。自定义扩展若与成员同名,IDE 与编译器会提示成员优先,扩展实际不可见地被遮蔽。
原理流程
- 编译期检查接收者静态类型的成员表。
- 匹配到同名成员:生成成员调用。
- 无成员:查找可见扩展函数。
- 多扩展候选按类型匹配与导入规则消歧。
代码或图示
class Box {
fun dump() = "member"
}
fun Box.dump() = "extension" // 被成员遮蔽
Box().dump() // member
常见误区
- 定义扩展期望改变已有成员行为:无效。
- 成员与扩展命名相近造成阅读混淆:命名应区分职责。
追问
- 答:扩展能否调用被遮蔽的同名成员?答:通过限定或原类实例访问,扩展本身不覆盖成员。
- 答:解析歧义报错如何修复?答:调整导入、显式限定接收者类型或重命名扩展。
04.8.1.3-033 inline 函数如何消除 lambda 运行时开销?
一句话结论
inline 把函数体展开到调用点,高阶函数传入的 lambda 不再编译为函数对象,避免每次调用创建 lambda 实例与间接调用开销。
概念解释
普通高阶函数接收函数类型参数,lambda 被包装为函数对象实例;内联后 lambda 代码并入调用点,闭包对象分配减少。代价是字节码体积随调用点复制增长。
原理流程
- 编译器标记 inline 函数。
- 每个调用点替换为函数体代码。
- lambda 体就地展开,不生成函数对象。
- 运行时无闭包分配与转发调用。
代码或图示
inline fun <T> measure(block: () -> T): T {
val start = System.nanoTime()
val result = block()
println("${System.nanoTime() - start}ns")
return result
}
measure { compute() }
常见误区
- 以为 inline 一定更快:大函数、多调用点时代码膨胀可能抵消收益。
- 内联后 lambda 捕获变量语义被误解:展开后按局部变量规则处理。
追问
- 答:哪些 lambda 不被内联?答:标注
noinline的参数保留为函数对象。 - 答:inline 适合小工具函数还是大函数?答:适合短小高频工具,大函数需评估体积成本。
04.8.1.3-034 inline 函数的字节码展开位置在哪里?
一句话结论
inline 函数体在每个调用点编译展开,函数自身字节码不保留为可调用方法;内联的 lambda 体也并入调用点,参数不再作为运行时函数对象传递。
概念解释
展开发生在编译期,调用点之间复制函数体。递归或无法内联的调用会回退为普通函数调用并给出诊断。理解展开位置有助于排查体积与调试信息问题。
原理流程
- 编译器扫描 inline 函数调用点。
- 函数体模板替换到调用处。
- 实参与 lambda 体按规则代入。
- 无法内联的结构(如递归)生成普通调用并提示。
代码或图示
inline fun twice(action: () -> Unit) { action(); action() }
fun demo() {
twice { println("x") }
// 展开后等价于两次执行 println("x")
}
常见误区
- 以为 inline 函数在 JVM 上还有独立方法入口:调用点已展开。
- 调试时期望步入 inline 函数源码:调试信息按编译产物映射。
追问
- 答:inline 函数公共 API 有什么兼容风险?答:函数体进入调用方字节码,修改内联实现可能破坏 ABI,见后续题目。
- 答:noinline 参数在展开点如何处理?答:该参数仍生成函数对象并传入展开后的代码。
04.8.1.3-035 noinline 在什么场景下保留 lambda 为对象?
一句话结论
inline 函数的某个参数标注 noinline 后,该 lambda 不被展开,仍编译为函数对象;用于需要把 lambda 存储、传递或作为对象使用的场景。
概念解释
默认 inline 把所有函数参数展开。当函数内需要把参数引用保存到字段、传入另一个非内联 API,或该 lambda 不适合就地展开时,用 noinline 保留对象形态。
原理流程
- inline 函数参数加
noinline。 - 编译器不为该参数展开 lambda 体。
- 参数作为函数类型对象传入函数体。
- 其余参数仍按 inline 规则展开。
代码或图示
inline fun <T> repeat(times: Int, crossinline body: () -> Unit, noinline final: () -> Unit) {
repeat(times) { body() }
storeCallback(final) // final 作为函数对象保存
}
fun storeCallback(cb: () -> Unit) { /* ... */ }
常见误区
- 对需要内联消除开销的参数误标
noinline:对象分配重新出现。 - 把
noinline用在非 inline 函数参数上:无意义且受限。
追问
- 答:
noinline与crossinline区别?答:前者保留函数对象;后者仍内联但禁止非局部返回。 - 答:noinline lambda 能否被内联函数再次内联?答:它已是函数对象,按普通高阶函数传递。
04.8.1.3-036 crossinline 如何禁止 lambda 的非局部返回?
一句话结论
crossinline 标注的内联 lambda 体被允许在另一执行上下文(如内部对象、循环回调)中调用,同时禁止 lambda 内使用非局部返回跳出外层函数。
概念解释
普通 inline lambda 可以裸 return 跳出外层函数;当内联体被包装到内部对象或异步回调中执行时,非局部返回在语义上不可行。crossinline 约束 lambda 只能用标签返回。
原理流程
- inline 函数把参数 lambda 传给嵌套对象/另一执行点。
- 标注
crossinline表明内联体在非直接上下文执行。 - 编译器禁止该 lambda 内非局部
return。 - 需要退出时使用标签
return@label。
代码或图示
inline fun postpone(crossinline action: () -> Unit) {
val runner = object : Runnable {
override fun run() = action()
}
runner.run()
}
常见误区
- 在 crossinline lambda 里写裸
return:编译报错。 - 混淆 noinline 与 crossinline:对象保留与否是 noinline,返回限制是 crossinline。
追问
- 答:crossinline 后 lambda 还是内联的吗?答:体仍参与内联展开,但返回语义受限。
- 答:什么场景必须用 crossinline?答:内联参数被内部类、回调注册或另一函数上下文调用时。
04.8.1.3-037 inline 与 reified 如何协同工作?
一句话结论
reified 必须依附 inline:内联展开把编译期实参类型带入函数体,reified 才能在展开代码中访问 T::class 与做 is T 判断。
概念解释
两者机制互补:inline 消除调用边界,reified 保留类型参数。没有 inline 展开,擦除后运行时拿不到 T;没有 reified,类型参数仍是普通擦除参数。
原理流程
- 声明
inline fun <reified T>。 - 调用点展开函数体。
- 实参类型写入展开代码。
- 函数内
T::class、is T基于具体类型编译。
代码或图示
inline fun <reified T> find(items: List<Any>): T? =
items.firstOrNull { it is T } as? T
常见误区
- 单独声明 reified 不写 inline:编译报错。
- 以为 reified 类型能跨内联边界长期保存:展开点之外不可用。
追问
- 答:reified 函数能否 noinline 参数?答:函数整体 inline,个别参数可 noinline;reified 参数本身不可 noinline。
- 答:reified 与泛型上界冲突吗?答:可同时声明上界,reified 实参需满足上界约束。
04.8.1.3-038 inline 对字节码体积有什么副作用?
一句话结论
每个调用点复制一份函数体,调用点越多字节码越大;大函数高频内联会膨胀方法体与体积,需要在消除 lambda 开销与代码体积之间权衡。
概念解释
内联收益是减少函数对象与调用开销,成本是代码复制。短小工具函数收益明显;大函数、多调用点应评估产物体积,必要时保留普通函数。
原理流程
- 编译器按调用点展开函数体。
- 每个调用点独立复制指令。
- 调用点数量乘函数体体积得到增量。
- 热点小函数内联划算,大函数需实测对比。
代码或图示
inline fun fast(a: Int, b: Int) = a + b // 短小,内联收益高
// 大段逻辑内联到几十个调用点会显著增加字节码体积
常见误区
- 给所有高阶函数加 inline:体积失控。
- 只看运行时性能不看产物体积:Android/受限包体场景需权衡。
追问
- 答:编译器是否自动决定内联?答:Kotlin 源码 inline 由显式标注;JVM 即时编译另有内联策略,两层机制不同。
- 答:如何测量体积影响?答:对比内联前后产物方法数与字节码大小,结合调用点数量评估。
04.8.1.3-039 inline 属性与可计算属性委托有什么关系?
一句话结论
属性访问器可标注 inline,访问器逻辑在使用点展开;它与委托属性是两套机制:inline 优化访问器,委托把读写交给委托对象。
概念解释
inline 属性适用于 getter/setter 逻辑简短、调用频繁的场景。委托属性通过 by 接入外部约定对象;二者可组合但职责不同,不要把内联委托理解为自动委托。
原理流程
- 属性访问器加
inline修饰。 - 访问器体在使用点展开。
- 委托属性声明
by 委托对象,读写转发到约定方法。 - 委托对象内部逻辑不受 inline 属性直接控制。
代码或图示
val debug: String
inline get() = System.getProperty("debug") ?: "false"
var cached: String by lazy { load() }
常见误区
- 以为 inline 属性替代 lazy/observable 委托:机制不同。
- 给复杂访问器加 inline:体积成本高于收益。
追问
- 答:inline 属性适用什么场景?答:短 getter、高频读取、无复杂状态逻辑。
- 答:委托属性的内联由谁决定?答:委托类实现约定方法,是否优化取决于委托实现与编译器。
04.8.1.3-040 lambda 中的非局部返回(non-local return)规则是什么?
一句话结论
普通 inline 高阶函数的 lambda 内裸 return 会跳出声明该 lambda 的外层函数;非 inline 高阶函数的 lambda 不能非局部返回,只能标签返回。
概念解释
非局部返回依赖内联展开:lambda 体并入外层函数,return 直接退出外层。传给普通函数的 lambda 是独立对象,裸 return 不被允许。crossinline 场景也禁止非局部返回。
原理流程
- lambda 作为 inline 参数:体展开到外层函数内。
- 裸
return退出外层函数。 - lambda 作为非 inline 参数:编译为函数对象,裸 return 报错。
- 局部退出用
return@label。
代码或图示
fun containsZero(items: List<Int>): Boolean {
items.forEach {
if (it == 0) return true // 非局部返回外层函数
}
return false
}
常见误区
- 在普通回调 lambda 里写裸
return:编译报错。 - 误判非局部返回退出的是 lambda 自身:实际退出外层函数。
追问
- 答:标签返回怎么写?答:
return@forEach value,只退出当前 lambda 迭代。 - 答:crossinline 为什么禁止非局部返回?答:内联体在另一执行上下文运行,语义上不能跳出外层。
04.8.1.3-041 内联高阶函数有哪些禁止与限制?
一句话结论
inline 函数不能递归内联(递归调用无法在调用点展开自身),部分受限场景编译器回退为普通调用并诊断;reified、noinline/crossinline 有各自约束组合。
概念解释
内联要求函数体可复制到调用点,递归引用自身会导致展开循环。编译器对不满足条件的内联请求给出警告或回退;公共 API 内联还受 ABI 兼容约束。
原理流程
- 编译器检查 inline 函数结构。
- 递归自调用:无法静态展开,按规则回退或报错。
- 受限参数标注组合校验通过。
- 不符合内联条件时编译器诊断提示。
代码或图示
// 递归函数不适合声明 inline:展开会无限复制
inline fun factorial(n: Int): Int = if (n <= 1) 1 else n * factorial(n - 1)
常见误区
- 期待所有高阶函数都能内联:结构受限。
- 忽略编译器内联回退警告:性能假设可能不成立。
追问
- 答:公共库 inline 函数改动有何风险?答:函数体被复制到调用方字节码,修改实现会影响已编译调用方,ABI 需谨慎。
- 答:inline 函数能否访问私有成员?答:在同一编译单元上下文内按可见性规则处理,具体以编译器诊断为准。
04.8.1.3-042 编译器契约(contracts)的作用与稳定性状态是什么?
一句话结论
contracts 让函数向编译器声明行为约定(如参数非空、返回值与参数关系),帮助智能转换与类型推断;其语法与稳定范围以 Kotlin 版本为准,使用前核对官方状态。
概念解释
标准库部分函数借助契约让编译器理解「调用后变量变非空」等结论,从而穿透 lambda 做 smart cast。用户自定义契约 API 属于演进中特性,不同版本可用性不同,不确定处标注待确认。
原理流程
- 函数声明行为约定(返回、参数、调用关系)。
- 编译器依据契约更新数据流结论。
- lambda 后变量被智能转换。
- 契约语法与支持范围按目标版本核对。
代码或图示
// 标准库契约示例思路:requireNotNull 调用后编译器知晓接收者非空
// 自定义 contract 写法与稳定性以官方文档及项目版本为准(待确认)
常见误区
- 把内部实验契约语法写入公共库:版本升级可能变化。
- 以为契约能运行时校验:契约是编译期数据流辅助。
追问
- 答:契约与运行时断言关系?答:断言在运行时抛异常;契约只在编译期辅助推断,二者不互相替代。
- 答:如何确认版本支持?答:查 kotlinlang.org contracts 章节并在工程编译验证。
04.8.1.3-043 contract 如何让智能转换穿透 lambda?
一句话结论
普通判空在 lambda 内部不影响外部变量类型;契约声明「lambda 返回后参数满足某条件」后,编译器可在 lambda 调用后对外部变量做智能转换。
概念解释
没有契约时,编译器不了解高阶函数对参数做了什么,lambda 结束后外部变量类型不收窄。契约把行为约定告诉编译器,使 smart cast 跨函数边界生效。
原理流程
- 高阶函数接收变量并在内部校验。
- 契约声明调用返回后参数非空/类型匹配。
- 编译器在调用点后收窄变量类型。
- 后续代码按收窄类型访问成员。
代码或图示
fun <T : Any> T?.requireNotNull(): T {
// 标准库实现通过契约让调用方在本调用后获得非空类型
return this ?: throw IllegalArgumentException()
}
fun demo(name: String?) {
val n = name.requireNotNull()
println(n.length) // n 已收窄为非空 String
}
常见误区
- 期望自定义校验函数自动穿透 lambda:需要契约支持,普通函数不传递结论。
- 把契约当作运行时空检查:运行时仍需断言抛错。
追问
- 答:穿透失败时的兜底写法?答:显式判空、
?:兜底或局部变量收窄。 - 答:契约在泛型函数中如何声明?答:按官方契约 DSL 描述参数与返回关系,版本可用性待确认。
04.8.1.3-044 DSL 在 Kotlin 中是什么概念?
一句话结论
DSL(领域特定语言)利用嵌套 lambda、接收者上下文与约定函数构建层级化配置或表达式,让代码读起来像领域语句,而不是普通命令式调用。
概念解释
Kotlin DSL 的基础是带接收者的 lambda:内层块拥有外部配置对象的上下文,可直接调用其方法。常见于构建器、配置声明、布局/路由定义。
原理流程
- 定义配置类与构建方法。
- 高阶函数接收带接收者 lambda。
- 嵌套块逐层配置子节点。
- 约定方法(
invoke、操作符)提供简洁语法。
代码或图示
data class Menu(val items: MutableList<Item> = mutableListOf())
data class Item(val name: String, val price: Int)
fun menu(block: Menu.() -> Unit): Menu = Menu().apply(block)
fun Menu.item(name: String, price: Int) { items.add(Item(name, price)) }
val m = menu {
item("coffee", 18)
item("tea", 12)
}
常见误区
- DSL 内暴露过多外部上下文:配置块可意外访问外层对象。
- 层级过深不拆分:可读性下降。
追问
- 答:DSL 与普通 builder 区别?答:DSL 用接收者 lambda 嵌套表达层级,builder 用链式方法调用。
- 答:DSL 类型安全吗?答:语法结构由编译期类型约束,非法结构编译报错;业务约束仍需运行时校验。
04.8.1.3-045 接收者 lambda 如何作为 DSL 基础?
一句话结论
Type.() -> Unit 类型的 lambda 在调用时把 Type 实例作为接收者传入,块内 this 指向配置对象,可直接调用其方法与属性,形成声明式层级。
概念解释
普通 lambda 无接收者,参数通过 it 访问;带接收者 lambda 拥有上下文对象。DSL 构建函数以接收者 lambda 为参数,嵌套块依次绑定子配置对象。
原理流程
- 构建函数声明
receiver.() -> Unit参数。 - 创建接收者实例。
- 把实例作为
this调用 lambda。 - 块内方法调用落到接收者对象上。
代码或图示
class ServerConfig { var host: String = ""; var port: Int = 8080 }
fun server(block: ServerConfig.() -> Unit) = ServerConfig().apply(block)
val cfg = server {
host = "0.0.0.0"
port = 9090
}
常见误区
- DSL 构建函数忘记 apply 接收者实例:lambda 内
this未绑定。 - 接收者类型过宽:内层块访问到不该见的成员。
追问
- 答:带接收者函数类型与普通函数类型如何转换?答:接收者作为首参,类型上有对应关系,具体以编译器规则为准。
- 答:嵌套 DSL 如何绑定子接收者?答:子构建函数创建子对象并以其为接收者调用内层 lambda。
04.8.1.3-046 @DslMarker 如何防止外部作用域隐式访问?
一句话结论
@DslMarker 标注在注解上,用于限定 DSL 接收者作用域:内层块只能访问当前层级接收者,隐式阻断外层接收者成员的直接调用,避免跨层级误访问。
概念解释
多层 DSL 中,内部块本应只操作子节点;没有标记时,外层接收者成员也可能被隐式调用。DslMarker 让同标记的外层接收者在内部块中不可见,必须显式限定。
原理流程
- 定义带
@DslMarker元注解的注解。 - 标注到各 DSL 接收者类型上。
- 内层块解析成员时屏蔽同标记外层接收者。
- 确需访问外层需显式保存引用并限定调用。
代码或图示
@DslMarker
annotation class MenuDsl
@MenuDsl
class Menu { fun item(name: String) {} }
@MenuDsl
class Item { fun option(name: String) {} }
常见误区
- 不给所有层级接收者加标记:屏蔽不完整。
- 把 DslMarker 当运行时安全措施:它是编译期作用域约束。
追问
- 答:需要访问外层接收者怎么办?答:在进入内层前保存外层引用,用显式限定调用。
- 答:DslMarker 注解如何定义?答:声明注解并加
@DslMarker元注解,具体写法以官方文档为准。
04.8.1.3-047 DSL 作用域层次与 this 消歧怎么做?
一句话结论
嵌套 DSL 每层绑定不同接收者,内层 this 指向当前子节点;访问父层对象需在进入前保存引用,用 this@父类型 或命名变量显式限定。
概念解释
作用域链上存在多个接收者,成员解析按最近接收者优先。DslMarker 可屏蔽外层隐式访问;显式限定消除歧义,避免子节点误调用父节点方法。
原理流程
- 外层构建函数绑定父接收者。
- 内层块创建子对象并绑定子接收者。
- 成员查找先匹配子接收者。
- 父层访问通过保存的引用或限定
this。
代码或图示
fun menu(block: Menu.() -> Unit) = Menu().apply(block)
fun Menu.section(title: String, block: Section.() -> Unit) {
val parent = this
Section(title).apply { block() /* 需访问 parent 时显式引用 */ }
}
常见误区
- 嵌套层不保存外层引用:内部无法回退访问父节点。
- 依赖隐式外层访问:与 DslMarker 约束冲突,编译报错。
追问
- 答:多个同类型接收者如何消歧?答:保存命名变量或用
this@类型限定。 - 答:DSL 中
it与this分别指什么?答:this是接收者;普通 lambda 参数用it,带接收者块内参数另写参数名。
04.8.1.3-048 标准库有哪些常见 DSL 构建器?
一句话结论
buildString、buildList、buildMap、listOf/mapOf 一类函数提供接收者构建上下文,按约定向集合或字符串缓冲追加内容后返回不可变结果。
概念解释
这些构建器是轻量 DSL:lambda 接收者是可变缓冲对象,块内调用追加方法,构建结束返回只读/不可变结果。与手写循环和缓冲拼接相比,结构更集中。
原理流程
- 构建函数创建内部可变缓冲。
- 以缓冲为接收者执行 lambda。
- 块内调用追加/put 方法。
- 返回转换后的不可变集合或字符串。
代码或图示
val text = buildString {
appendLine("header")
append("count=").append(3)
}
val list = buildList { add(1); add(2) }
常见误区
- 把构建器返回对象当可变继续修改:返回值通常是只读视图。
- 在构建 lambda 里做远程调用或重副作用:构建时机不直观。
追问
- 答:
buildList与mutableListOf区别?答:前者在构建块内可变,返回只读 List;后者直接暴露可变集合。 - 答:自定义 DSL 可参考哪些约定?答:构建函数返回不可变结果,子节点方法挂在父接收者上。
04.8.1.3-049 自定义 DSL 的约束函数(apply/invoke/operator)如何组织?
一句话结论
DSL 常用 apply 配置接收者、invoke 约定让对象可像函数一样调用、操作符约定简化节点声明;约束方法挂在父接收者上,按层级暴露子节点。
概念解释
构建器方法分两类:配置当前对象的方法,与创建子节点并加入父容器的方法。operator invoke 可让配置对象直接被调用,操作符重载提供 +、[] 一类语法。
原理流程
- 父接收者声明子节点工厂方法。
- 工厂方法创建子对象、加入容器、以子对象为接收者执行 lambda。
- 需要简洁调用时实现
invoke/操作符约定。 - 构建完成返回根配置对象。
代码或图示
class Form { val fields = mutableListOf<Field>() }
class Field(val name: String)
fun Form.field(name: String, block: Field.() -> Unit = {}) {
val f = Field(name).apply(block)
fields.add(f)
}
常见误区
- 子节点方法挂错接收者:内层块找不到方法。
- 暴露内部可变缓冲:外部可绕过构建规则改结构。
追问
- 答:
invoke约定签名是什么?答:operator fun invoke(...),调用时对象后接括号参数。 - 答:DSL 如何做参数校验?答:构建期约定方法内校验,或最终配置对象校验后使用。
04.8.1.3-050 操作符重载约定有哪些?
一句话结论
Kotlin 为固定符号映射约定方法:plus 对应 +、minus 对应 -、times 对应 *、contains 对应 in 等;声明 operator fun 满足签名后即可用符号表达式。
概念解释
操作符重载是编译期语法映射,不生成新 JVM 指令。每种符号有固定约定名与参数/返回类型要求;语义应与内置类型直觉一致,避免可读性陷阱。
原理流程
- 类型声明
operator fun plus(other: T): T。 - 编译器把
a + b解析为a.plus(b)。 - 签名不符时操作符表达式编译报错。
- 运行时调用约定方法。
代码或图示
data class Vec(val x: Int, val y: Int) {
operator fun plus(other: Vec) = Vec(x + other.x, y + other.y)
}
val v = Vec(1, 2) + Vec(3, 4)
常见误区
- 漏掉
operator修饰:符号不可用。 - 操作符语义违背直觉(如
-不做减法):维护成本高。
追问
- 答:相等性
==走哪个约定?答:走equals,不是 plus 一类操作符;身份比较为===。 - 答:完整操作符约定列表在哪里查?答:kotlinlang.org 操作符重载章节。
04.8.1.3-051 中缀函数 infix 的调用形式与限制是什么?
一句话结论
infix fun 单参数成员/扩展函数可用 a fn b 中缀形式调用;必须是单参数、不能是可变参数,中缀形式省略点号与括号。
概念解释
中缀用于领域可读表达式,如 to、until、业务谓词。语法限制严格:参数固定一个,接收者明确;普通点号调用仍可使用。
原理流程
- 函数加
infix修饰,声明单参数。 - 调用写
接收者 函数名 参数。 - 编译器解析为
接收者.函数名(参数)。 - 多参数或扩展约束不符时不可中缀调用。
代码或图示
infix fun Int.gcd(other: Int): Int {
var a = this; var b = other
while (b != 0) { val t = b; b = a % b; a = t }
return a
}
println(12 gcd 18)
常见误区
- 给多参数函数加
infix:编译报错。 - 公共 API 滥用中缀:语义不明时点号调用更清晰。
追问
- 答:标准库中缀函数有哪些?答:
to构造 Pair,until、downTo、step范围相关。 - 答:中缀与操作符重载区别?答:中缀是自定义命名函数的语法;操作符是固定符号映射约定方法。
04.8.1.3-052 解构约定 componentN 如何在自定义类型上实现?
一句话结论
自定义类型声明 operator fun component1()、component2() 等方法后,即可用 val (a, b) = instance 解构;返回顺序与组件编号对应。
概念解释
解构依赖组件约定,data class 自动生成。普通类手动实现组件方法;组件数量、类型与解构变量一一对应,多余组件可用 _ 跳过。
原理流程
- 声明
operator fun componentN(): T。 - 解构声明按编号调用组件方法。
- 变量类型按组件返回类型推断。
- 组件缺失或数量不符编译报错。
代码或图示
class Point(val x: Int, val y: Int) {
operator fun component1() = x
operator fun component2() = y
}
val (px, py) = Point(3, 4)
常见误区
- 组件编号不连续或顺序错乱:解构变量语义错位。
- 普通类未实现组件方法就解构:编译失败。
追问
- 答:Map 条目解构基于什么?答:
Map.Entry自带component1/component2约定。 - 答:组件方法可以返回可空类型吗?答:可以,解构变量类型相应可空。
04.8.1.3-053 invoke 约定如何让对象像函数一样调用?
一句话结论
实现 operator fun invoke(...) 后,对象实例可后接括号调用,语法上等价于调用 invoke 方法;常用于策略对象、回调与 DSL 节点。
概念解释
invoke 是函数式调用约定:对象持有行为,调用方按函数形式触发。可带参数与返回值,可重载多个 invoke 形式。
原理流程
- 类型声明
operator fun invoke(args): R。 - 调用
obj(args)解析为obj.invoke(args)。 - 函数体执行对象持有的行为。
- 重载按参数签名选择 invoke 版本。
代码或图示
class Greeter(val name: String) {
operator fun invoke(greeting: String) = "$greeting, $name"
}
val g = Greeter("Ann")
println(g("Hi"))
常见误区
- 忘记
operator修饰:括号调用不可用。 - 在状态多变的对象上用 invoke 掩盖行为分歧:可读性下降。
追问
- 答:invoke 能否挂在扩展上?答:可以,扩展形式声明 operator invoke。
- 答:函数类型实例本身有 invoke 吗?答:函数类型对象按调用约定执行,与自定义 invoke 机制一致。
04.8.1.3-054 get/set/iterator 约定如何使用?
一句话结论
operator fun get(index) 支持 obj[i],set 支持赋值下标,iterator 支持 for 遍历;约定方法满足签名后集合式语法即可用。
概念解释
下标与迭代是标准集合语法约定。自定义容器实现 get/set/iterator 后,可用方括号访问与 for 循环遍历,无需继承特定集合类。
原理流程
- 声明
operator fun get(idx: T): R。 obj[i]编译为obj.get(i)。set约定支持obj[i] = v。iterator约定返回迭代器,供 for 循环使用。
代码或图示
class Matrix(val rows: IntArray) {
operator fun get(i: Int) = rows[i]
operator fun iterator() = rows.iterator()
}
val m = Matrix(intArrayOf(1, 2, 3))
println(m[1])
for (v in m) { println(v) }
常见误区
- 下标方法漏
operator:方括号语法不可用。 - iterator 返回类型不满足迭代协议:for 循环报错。
追问
- 答:多维下标约定怎么写?答:get 可声明多参数,
obj[x, y]对应get(x, y)。 - 答:set 约定返回类型?答:通常返回 Unit,赋值表达式语法由编译器处理。
04.8.1.3-055 比较操作符与 compareTo 约定是什么?
一句话结论
<、>、<=、>= 映射到 compareTo 约定方法,返回负数/零/正数表示顺序;实现 Comparable 风格的 compareTo 后比较操作符可用。
概念解释
比较约定与数值直觉一致:a < b 调用 a.compareTo(b) < 0。类型实现比较方法后,可在排序、区间与条件判断中使用比较符号。
原理流程
- 声明
operator fun compareTo(other: T): Int。 - 编译器把比较符号解析为 compareTo 加结果判断。
- 返回值按小于/等于/大于约定。
- 排序工具按 compareTo 结果排列。
代码或图示
data class Version(val major: Int, val minor: Int) : Comparable<Version> {
override fun compareTo(other: Version): Int =
compareValuesBy(this, other, { it.major }, { it.minor })
}
println(Version(1, 2) < Version(1, 10))
常见误区
- compareTo 返回值方向写反:比较符号结果颠倒。
- 只实现
equals不实现 compareTo:排序比较不可用。
追问
- 答:compareTo 与 equals 必须一致吗?答:建议顺序与相等性一致,避免排序与判等矛盾。
- 答:标准库比较工具?答:
compareValuesBy、comparator一类辅助函数。
04.8.1.3-056 范围约定 rangeTo/until 如何工作?
一句话结论
.. 调用 rangeTo 生成闭区间,until 生成左闭右开区间;类型实现范围约定后可用区间字面量与 in 包含判断。
概念解释
区间约定让自定义类型也能参与范围表达。标准库整数/字符区间由标准类型实现;rangeTo 返回区间对象,until 是扩展函数排除上界。
原理流程
a..b解析为a.rangeTo(b)。- 区间对象实现迭代与包含协议。
in调用区间contains判断。until生成排除终点的区间。
代码或图示
val closed = 1..10
val halfOpen = 0 until size
if (n in closed) { /* contains 判断 */ }
常见误区
- 递减区间用
10..1:空区间,应downTo。 - 索引遍历用闭区间导致越界:应用
until。
追问
- 答:自定义类型如何支持
..?答:实现rangeTo返回区间类型,并满足迭代/包含约定。 - 答:区间与数组区别?答:区间是范围迭代概念,不逐个存储元素,见基础类型章节。
04.8.1.3-057 扩展函数在 Java 侧为什么不可见?
一句话结论
扩展是 Kotlin 编译期静态函数,不是原类成员;Java 侧看不到接收者类型上的扩展方法,只能按生成的静态工具方法形式调用。
概念解释
扩展不写入原类字节码,Java 反射与方法列表中不存在该成员。互操作时 Kotlin 顶层/扩展函数编译到文件包装类,Java 需通过工具类调用。
原理流程
- 扩展编译为静态函数,首参为接收者。
- 原类方法表不包含扩展。
- Java 按包装类静态方法签名查找。
- 直接在 Java 实例上调扩展名找不到方法。
代码或图示
// Kotlin
fun String.shout(): String = this.uppercase()
// Java 侧需调用生成的静态工具方法,而非 str.shout()
常见误区
- 以为 Java 能像 Kotlin 一样点号调用扩展:不行。
- 在框架接口文档中把扩展写成类成员:误导 Java 调用方。
追问
- 答:如何向 Java 暴露便捷方法?答:声明为类成员方法或伴生/顶层静态函数,配合
@JvmName/@JvmStatic。 - 答:扩展函数字节码归属哪个类?答:顶层扩展归属文件包装类,具体类名以编译产物为准。
04.8.1.3-058 静态扩展与包级函数在 Java 侧是什么形态?
一句话结论
Kotlin 顶层函数与扩展编译到文件对应的包装类静态方法;@JvmName 可调整包装类或方法名,Java 按静态方法调用,不体现接收者扩展关系。
概念解释
包级函数是 Kotlin 组织工具方法的方式,字节码落到文件包装类。互操作命名可由注解控制;理解形态有助于排查 Java 调用与反射问题。
原理流程
- 顶层函数编译为包装类静态方法。
- 扩展函数首参为接收者参数。
@JvmName覆盖生成类名/方法名。- Java 调用静态方法并传入接收者与参数。
代码或图示
@file:JvmName("StringUtils")
fun String.prefix(p: String) = p + this
// Java: StringUtils.prefix("x", "y")
常见误区
- 猜测包装类名而不查编译产物:命名可能带后缀或按注解变化。
- 把扩展当成员写进 Java 接口文档。
追问
- 答:
@JvmName能改方法名吗?答:可作用于文件级类名或函数级方法名,具体规则以文档为准。 - 答:互操作完整注解见哪节?答:04.8.1.4 集合、序列、作用域函数与 Java 互操作。
04.8.1.3-059 泛型与 Java 通配符如何映射?
一句话结论
Java ? extends T 对应 Kotlin 协变投影(out 位置),? super T 对应逆变投影(in 位置);只读生产者与消费者关系两侧一致。
概念解释
两侧都表达泛型子类型兼容,只是声明位置不同。互操作时 Kotlin 读取 Java 签名,把通配符转成投影类型;反向 Kotlin 型变导出为 Java 通配符签名。
原理流程
- Java
List<? extends Animal>:生产者协变。 - Kotlin 侧呈现为
out Animal投影。 - Java
? super Animal:消费者逆变。 - 不变类型两侧均为固定实参。
代码或图示
// Java: List<? extends Number>
// Kotlin 读取为协变投影;只读元素按 Number 类型使用
fun read(numbers: List<out Number>) { /* ... */ }
常见误区
- 把
? super理解成协变:方向相反。 - 在投影类型上做越界写入:编译受限。
追问
- 答:Java 无界通配符
?对应什么?答:近似 Kotlin 星投影*,读写受限。 - 答:通配符在 Kotlin 源码里怎么写?答:声明点型变
in/out,使用点投影配合星投影。
04.8.1.3-060 Java 通配符在 Kotlin 调用时呈现为什么类型?
一句话结论
Kotlin 编译器按 Java 签名把 ? extends/? super/无界通配符映射为 out/in 投影或星投影;调用方按投影安全边界读取与写入。
概念解释
读取 Java 类签名时,通配符信息保留为投影类型。协变投影可读不可写,逆变投影可写(按下界类型)读取受限;无界通配符按星投影处理。
原理流程
- 解析 Java 方法/字段泛型签名。
- 通配符转换为 Kotlin 投影类型。
- 编译器按投影位置检查读写操作。
- 不兼容读写报错。
代码或图示
// Java 方法:List<? super Integer> getSink()
// Kotlin 侧按逆变投影理解,可写入 Integer,读取为上界类型
fun sink(s: MutableList<in Int>) { s.add(1) }
常见误区
- 忽略投影只读/只写限制:直接读写编译报错。
- 把通配符类型当固定实参比较:类型不兼容。
追问
- 答:平台类型与通配符叠加如何处理?答:空性未知 + 投影未知,边界处建议显式收口类型。
- 答:互操作签名导出规则以什么为准?答:编译器版本与官方互操作文档,不确定处实测。
04.8.1.3-061 型变在标准库集合接口上如何标注?
一句话结论
List<out E> 是协变只读生产者,MutableList<T> 是不变可变集合;只读接口只产出元素所以协变,可变接口同时读写所以不变。
概念解释
标准库把只读与可变拆分接口,型变标注跟随读写位置。Set<out E> 同理;Map 的键值型变按位置分别处理。理解标注有助于判断集合赋值兼容。
原理流程
- 只读集合只提供读取方法,E 在返回位置。
- 声明
out E,子类型实参可向上替换。 - 可变集合提供 add/set,E 出现在参数位置。
- 读写并存保持不变。
代码或图示
val strings: List<String> = listOf("a")
val anyList: List<Any> = strings // 协变兼容
val mut: MutableList<String> = mutableListOf()
// val mAny: MutableList<Any> = mut // 不变,不兼容
常见误区
- 把 MutableList 当协变使用:写入位置破坏安全。
- 只读 List 引用可变实现:外部不能通过接口改,但底层状态仍可变。
追问
- 答:
List<String>能否赋给List<Any>?答:可以,只读协变。 - 答:Map 键值型变?答:键值按各自位置规则标注,具体以标准库签名为准。
04.8.1.3-062 泛型可空性:List<T?> 与 List<T>? 有什么区别?
一句话结论
List<T?> 表示集合存在但元素可空;List<T>? 表示集合引用本身可空,元素类型由 T 决定。两层可空性独立,判断与访问分别处理。
概念解释
外层 ? 控制容器引用是否可空,内层 ? 控制元素是否可空。组合 List<T?>? 同时表达两层缺失;访问时先判容器,再处理元素空值。
原理流程
- 外层可空:安全调用
?.访问集合方法。 - 内层可空:元素取值后判空或过滤。
- 类型参数上界决定 T 本身是否可空。
- 两层检查互不替代。
代码或图示
var a: List<String?> = listOf("x", null) // 元素可空
var b: List<String>? = null // 容器可空
var c: List<String?>? = null // 两层可空
常见误区
- 只判容器空就直接用元素:元素仍可能为 null。
- 把元素可空写成容器可空:语义错位。
追问
- 答:
filterNotNull处理哪一层?答:剔除集合内空元素,不处理容器引用空值。 - 答:泛型参数 T 默认可空吗?答:默认上界
Any?,T 实参可为可空类型。
04.8.1.3-063 多类型参数与函数类型参数如何声明?
一句话结论
泛型函数可声明多个类型参数,按逗号分隔;函数类型作为参数时类型形参贯穿函数签名,如 (T) -> R,类型推断同时约束两层。
概念解释
多类型参数常见于双映射、二元组合、工厂场景。函数类型参数的入参与返回类型引用类型形参,编译器从 lambda 与实参两侧推断。
原理流程
- 声明
<T, R>多类型参数。 - 参数/返回类型引用各形参。
- 函数类型
(T) -> R绑定形参。 - 调用处推断实参或显式指定。
代码或图示
fun <T, R> List<T>.map(transform: (T) -> R): List<R> =
mapTo(mutableListOf(), transform)
fun <A, B> pair(a: A, b: B): Pair<A, B> = Pair(a, b)
常见误区
- 函数类型参数与类型形参不对应:推断报错。
- 多类型参数命名混淆:按业务含义命名。
追问
- 答:函数类型自身型变?答:参数位置逆变、返回位置协变,见后续函数类型型变题。
- 答:类型参数能有多个上界吗?答:可以按多界约束规则声明。
04.8.1.3-064 类型别名如何改善泛型可读性?
一句话结论
嵌套泛型与函数类型可用 typealias 命名,函数签名只表达业务含义;别名与原类型等价,不产生独立类型,配合泛型实参保持类型安全。
概念解释
复杂签名如 (Result<T>, List<Retry>) -> Unit 重复出现时,别名把类型结构隐藏。泛型实参仍由编译器检查,别名不弱化类型约束。
原理流程
- 识别重复出现的复杂泛型/函数类型。
- 定义带类型参数的别名。
- 签名与属性使用别名。
- 编译期展开为原类型。
代码或图示
typealias Handler<T> = (Result<T>, List<String>) -> Unit
typealias Table<K, V> = Map<K, List<V>>
fun <T> subscribe(handler: Handler<T>) { /* ... */ }
常见误区
- 给只出现一次的类型起别名:增加跳转成本。
- 期待别名产生独立类型:与类型别名规则冲突。
追问
- 答:别名能带泛型上界吗?答:别名参数按声明传递,上界在使用处或原类型约束。
- 答:别名与扩展函数配合?答:可在扩展接收者类型上使用别名简化签名。
04.8.1.3-065 场景:如何写出型变正确的生产者/消费者接口?
一句话结论
只产出 T 的接口标 out T,只消费 T 的接口标 in T;同时读写保持不变,评审方法签名确认 T 只出现在允许的位置。
概念解释
设计接口时先划分读写方向:数据源是生产者,写入端是消费者。型变标注后检查方法签名,协变接口不能有 T 写入参数,逆变接口不能返回 T。
原理流程
- 列出接口方法中 T 出现的位置。
- 仅返回位置:声明
out。 - 仅参数位置:声明
in。 - 两处都有:不变,或拆分只读/可变接口。
代码或图示
interface Source<out T> { fun poll(): T? }
interface Sink<in T> { fun push(item: T) }
class Combined<T>(private val src: Source<T>, private val sink: Sink<T>)
常见误区
- 协变接口遗留 add 方法:编译报错。
- 一个接口承担读写又强求型变:应拆分。
追问
- 答:型变标注后外部赋值兼容性如何验证?答:编写子类型实参赋值父类型变量的编译用例。
- 答:标准库哪些接口是范例?答:
List<out E>生产者,MutableList不变,比较器逆变。
04.8.1.3-066 场景:如何用 reified 实现 JSON 反序列化辅助?
一句话结论
封装 reified 内联扩展调用序列化库,把目标类型从调用处带入;库不支持 reified 时退化为显式传入 KClass,并核对库版本兼容性。
概念解释
业务层希望写 parse<User>(json) 而不是传类对象。reified 函数在编译期保留 T,调用底层库的类型化 API;具体库 API 名称与版本支持需实测确认。
原理流程
- 定义
inline fun <reified T> parse(json: String): T?。 - 函数内调用序列化库按 T 解码。
- 调用处省略类对象参数。
- 库不支持时改为接收
KClass<T>参数的普通函数。
代码或图示
inline fun <reified T> deserialize(json: String): T? {
// 底层调用所用序列化库的类型化 API;具体方法名按库版本为准
return runCatching { /* library.readValue(json, T::class.java) */ }.getOrNull()
}
常见误区
- 假设所有 JSON 库都提供 reified 扩展:需逐库验证。
- 用 reified 恢复泛型容器元素类型:擦除后不可得。
追问
- 答:泛型集合反序列化怎么办?答:库需支持类型令牌/泛型序列化器,reified 不能直接携带嵌套实参。
- 答:待确认点写什么?答:库版本、API 名称、正反序列化结果与异常路径。
04.8.1.3-067 场景:如何用扩展函数收敛工具方法组织?
一句话结论
按类型领域聚合扩展函数到工具文件,接收者类型明确、职责单一;业务代码链式调用,避免在各业务类内复制重复工具逻辑。
概念解释
扩展把「对某类型的操作」挂到类型上,调用者按接收者发现方法。组织时按接收者类型与领域分组,控制可见性,避免扩展泛滥与同名冲突。
原理流程
- 识别重复出现的类型操作。
- 按接收者类型建立工具文件。
- 实现扩展函数并补充文档/测试。
- 业务处导入后链式复用。
代码或图示
// order/OrderExt.kt
fun Order.isExpired(): Boolean = expiresAt < System.currentTimeMillis()
fun Order.totalQty(): Int = items.sumOf { it.quantity }
常见误区
- 扩展里操作多个无关类型:职责混杂。
- 公共扩展暴露内部可变状态:封装被破坏。
追问
- 答:扩展与工具类静态方法怎么选?答:接收者单一、链式可读用扩展;多参数无关操作用顶层/工具类函数。
- 答:扩展可见性如何控制?答:按文件/模块声明 private/internal,必要时公开导入。
04.8.1.3-068 场景:如何用 DSL 构建一个配置对象?
一句话结论
定义根配置类与子节点类,根构建函数接收者 lambda 内声明子节点方法;嵌套块逐层绑定子接收者,构建完成返回不可变配置实例。
概念解释
DSL 配置比链式 builder 更贴近声明式结构。步骤:配置数据类、构建函数、子节点工厂、接收者上下文、最终校验与不可变返回。
原理流程
- 声明配置数据类与默认值。
- 根构建函数创建根实例并 apply lambda。
- 子方法创建子对象、加入容器、绑定子接收者。
- 校验配置后返回只读实例。
代码或图示
data class Server(val host: String = "0.0.0.0", val ports: List<Int> = emptyList())
fun server(block: ServerConfig.() -> Unit): Server {
val cfg = ServerConfig().apply(block)
return cfg.toServer()
}
class ServerConfig {
var host: String = "0.0.0.0"
private val ports = mutableListOf<Int>()
fun port(p: Int) { ports.add(p) }
fun toServer() = Server(host, ports)
}
常见误区
- 构建函数返回内部可变配置:外部可绕过校验修改。
- 子节点方法挂错接收者:内层块解析不到方法。
追问
- 答:DSL 中如何强制必填项?答:构建期校验或配置对象校验,缺失即抛配置异常。
- 答:嵌套层级多如何避免 this 混乱?答:配合 DslMarker 与显式外层引用保存。
04.8.1.3-069 场景:如何用 @DslMarker 解决层级访问冲突?
一句话结论
定义 DSL 标记注解并标注到各层接收者类型,内层块隐式访问外层同标记接收者会被编译阻断;需要跨层访问时显式保存外层引用并限定调用。
概念解释
冲突表现为内层块误调父节点方法。DslMarker 从编译期收窄作用域,让每个层级只能操作当前接收者。标记应覆盖根节点到叶子节点全部 DSL 类型。
原理流程
- 声明
@DslMarker元注解标注的自定义注解。 - 各 DSL 接收者类/接口标注该注解。
- 内层解析成员时屏蔽外层同标记接收者。
- 显式引用保存后可访问父层成员。
代码或图示
@DslMarker
annotation class FormDsl
@FormDsl
class Form { fun field(name: String) {} }
@FormDsl
class Field { fun label(text: String) {} }
常见误区
- 只标注根节点:子层仍可隐式访问父层。
- 把标记加在普通业务类上:收窄无关作用域。
追问
- 答:DslMarker 是运行时检查吗?答:不是,编译期作用域约束,运行时无拦截逻辑。
- 答:跨层读取父配置怎么做?答:进入内层前把父接收者存入命名变量,内层通过变量访问。
04.8.1.3-070 性能:inline 消除 lambda 对象分配的量化认知是什么?
一句话结论
未内联的高阶函数每次调用可能创建 lambda 函数对象;内联后该对象分配消除,热点循环中累积的分配与间接调用随之减少,但代价是调用点代码复制。
概念解释
性能收益来自两部分:闭包对象不再实例化,调用不再经过函数对象转发。具体节省取决于 lambda 是否捕获变量、调用频率与函数体大小;应以实测分配与耗时为准。
原理流程
- 普通高阶函数:lambda 包装为函数对象实例。
- 内联后:lambda 体并入调用点,无对象分配。
- 热点路径减少堆分配与 GC 压力。
- 大函数多调用点时代码体积增长抵消部分收益。
代码或图示
inline fun repeat(times: Int, action: (Int) -> Unit) {
for (i in 0 until times) action(i)
}
repeat(10_000) { println(it) } // 无 lambda 对象逐次分配
常见误区
- 宣称 inline 一定提速:需结合调用频率与函数体积实测。
- 忽略捕获变量的内联语义:展开后变量按局部规则处理。
追问
- 答:noinline lambda 还有分配吗?答:有,该参数保留为函数对象。
- 答:如何测量分配?答:查看堆分配热点、对象计数与耗时对比内联前后产物。
04.8.1.3-071 性能:reified 是否在运行时创建类型对象?
一句话结论
reified 类型信息在编译期展开带入,不额外创建运行时类型对象;T::class 引用的是已存在的类对象,reified 机制本身不生成新的类型令牌实例。
概念解释
与普通反射传入 Class 对象不同,reified 依赖编译期类型。运行时访问 T::class 取得 JVM 已有类对象,无内联期额外分配;成本主要在编译期展开。
原理流程
- 调用点展开时写入具体类型。
- 函数内
T::class解析为该类型类对象引用。 - 类对象由 JVM 类加载提供,不为 reified 新建。
- 反射调用按既有类对象执行。
代码或图示
inline fun <reified T> typeName(): String = T::class.java.name
常见误区
- 以为 reified 在运行时生成类型标记对象:它是编译期保留。
- 在展开点之外长期持有 reified 类型引用:不可用。
追问
- 答:reified 与显式传
KClass性能差别?答:后者每次传类对象引用;reified 编译期确定,运行时无参数对象传递。 - 答:类型擦除容器元素类型能靠 reified 恢复吗?答:不能,外层类型可判,元素实参仍擦除。
04.8.1.3-072 性能:扩展函数是否增加虚分发成本?
一句话结论
扩展编译为静态函数调用,不进入虚方法表,没有多态分派开销;调用直接绑定静态解析的实现,性能上接近普通静态方法调用。
概念解释
与成员虚方法按实际类型分派不同,扩展在编译期确定目标函数。运行时调用是静态转发,不产生虚查找;但扩展不能被子类覆写,这是静态解析的代价。
原理流程
- 编译期解析接收者类型对应扩展函数。
- 生成静态调用指令,接收者作为首参。
- 运行时不做虚方法表查找。
- 调用成本接近直接静态调用。
代码或图示
fun String.shout(): String = this.uppercase()
"hello".shout() // 静态解析,非虚分派
常见误区
- 把扩展当成员方法期待重写:分发模型不同。
- 高频扩展调用叠加多层链式:方法调用次数仍需计入成本。
追问
- 答:扩展与顶层普通函数性能差异?答:基本一致,都是静态调用,接收者作为参数传入。
- 答:成员虚方法何时使用?答:需要运行时多态分派时使用类层级开放成员。
04.8.1.3-073 坑:扩展静态解析导致的多态误判有哪些表现?
一句话结论
变量声明为父类型时,同名扩展按父类型解析,即使实际是子类实例;期待按实际类型走子类扩展会得到错误结果,这是静态解析而非虚分派。
概念解释
误判常出现在多类型层级与策略分发场景。修复方式是把行为改为接口/开放成员,或用 sealed + when 按实际类型分派。
原理流程
- 定义父类、子类与各自同名扩展。
- 父类型变量持有子类实例。
- 编译期按父类型选择扩展。
- 运行时不切换到子类扩展。
代码或图示
open class Transport
class Car : Transport()
fun Transport.desc() = "transport"
fun Car.desc() = "car"
val t: Transport = Car()
t.desc() // transport,而非 car
常见误区
- 调试时误以为运行时类型判断失效:实际是扩展静态解析规则。
- 用扩展实现状态机分发:应改用类型层级或 when 分派。
追问
- 答:如何按实际类型调用?答:定义接口方法由子类覆盖,或
when (t)匹配类型后调用对应扩展。 - 答:成员方法为什么没有这个问题?答:成员进入虚方法表,运行时按实例分派。
04.8.1.3-074 坑:crossinline/noinline 混用有哪些编译报错?
一句话结论
noinline 参数被传给需要内联上下文的结构会报错;crossinline lambda 内写裸非局部 return 报错;两个修饰符作用于同一参数的冲突组合也会被编译器拒绝。
概念解释
两类修饰符解决不同问题:noinline 保留函数对象,crossinline 限制返回语义。混用违反各自约束时,编译器在参数位置或 lambda 体内给出诊断。
原理流程
- 检查参数修饰组合是否合法。
- noinline 参数不能参与内联展开上下文。
- crossinline 内禁止非局部返回。
- 冲突组合在编译期报错。
代码或图示
inline fun demo(
noinline a: () -> Unit,
crossinline b: () -> Unit
) {
// b 内不能裸 return 外层函数
val runner = object : Runnable { override fun run() = b() }
runner.run()
}
常见误区
- 以为 crossinline 就是不内联:它仍内联,只限制返回。
- 给同一参数同时标 noinline 与 crossinline:语义冲突。
追问
- 答:报错位置如何定位?答:诊断指向参数声明或 lambda 内 return 语句,按修饰符语义调整。
- 答:noinline 后还能 reified 吗?答:reified 属于函数类型参数,与参数 noinline 是不同维度,组合规则以编译器为准。
04.8.1.3-075 坑:inline 函数内被捕获变量的修改语义是什么?
一句话结论
内联后捕获变量成为调用点局部变量,lambda 内修改会作用于外层局部变量;不再经过闭包对象读写,需注意多段 lambda 共享同一变量时的可见性。
概念解释
普通 lambda 捕获变量通过闭包对象读写;内联展开后变量并入调用点局部作用域,修改直接反映到外层。同一变量被多个内联 lambda 引用时,状态变化在各段间可见。
原理流程
- 编译器识别被 lambda 捕获的局部变量。
- 内联展开后变量留在调用点作用域。
- lambda 体对变量的读写成为局部变量读写。
- 多段 lambda 共享同一变量,按顺序观察修改。
代码或图示
fun accumulate(): Int {
var sum = 0
repeat(3) { sum += it } // 内联后 sum 为外层局部变量
return sum
}
常见误区
- 以为内联 lambda 有独立闭包副本:展开后共享外层变量。
- 多段回调修改同一变量:状态顺序依赖难以追踪。
追问
- 答:noinline lambda 捕获变量如何读写?答:保留闭包对象,通过对象读写捕获变量。
- 答:内联修改外部 var 有什么风险?答:控制流隐蔽,复杂逻辑应改用显式返回值传递。
04.8.1.3-076 坑:DSL 中误访问外层接收者有什么后果?
一句话结论
内层块未受限访问外层接收者,会误调父节点方法或读取父配置,产生结构错误;DslMarker 与显式引用控制是主要防护,漏标标记则风险回流。
概念解释
误访问在编译期不报错(成员确实存在),但业务结构错误:子节点操作了父节点。DSL 设计时应明确每层允许的接收者成员,并用标记收窄作用域。
原理流程
- 内层块解析成员,沿接收者链查找。
- 未加 DslMarker 时外层成员隐式可见。
- 误调父方法改变父配置。
- 编译通过但运行结构不符合预期。
代码或图示
class Page { fun title(t: String) {} }
class Section { fun body(t: String) {} }
// 未标记时 Section 块内可能误调用 Page.title
常见误区
- 依赖命名习惯防止误访问:编译期无强制约束。
- 嵌套块过长不拆分:接收者链复杂,误访问概率升高。
追问
- 答:如何审查 DSL 作用域?答:检查每层接收者类型与 DslMarker 标注,确认内层可见成员清单。
- 答:误访问后如何调试?答:跟踪配置对象变化路径,定位哪一层修改了父节点。
04.8.1.3-077 坑:星投影丢失类型信息后如何安全回退?
一句话结论
星投影只能按上界读取,写入受限;需要精确实参时,应在数据结构中保存类型令牌或用 reified 函数在编译期携带类型,不要在投影上强转。
概念解释
拿到 List<*> 后无法知道元素实参,盲目 as List<String> 是未检查强转。安全路径:显式类型令牌、reified 过滤,或在边界处把投影收窄为确定类型。
原理流程
- 投影类型按上界暴露读取能力。
- 需要具体类型时检查类型令牌。
- reified 函数在编译期保留目标类型。
- 强转前确认类型兼容,避免运行时 ClassCastException。
代码或图示
fun <T> collect(items: List<*>, type: KClass<T>): List<T> =
items.filterIsInstance(type.java)
inline fun <reified T> collectReified(items: List<*>): List<T> =
items.filterIsInstance<T>()
常见误区
- 对星投影直接做泛型强转:擦除后检查不到位。
- 把
List<*>当作List<Any?>写入:写入位置受限。
追问
- 答:filterIsInstance 如何保留类型?答:运行时按类实例判断并强转,reified 版本在编译期携带类型。
- 答:类型令牌存哪里?答:领域对象或序列化上下文显式保存 KClass/Class 引用。
04.8.1.3-078 坑:reified 与匿名类、反射有哪些边界?
一句话结论
reified 只在 inline 函数编译期上下文有效,不能传给匿名类实例长期保存;反射拿到的类对象仍受擦除限制,匿名类内部不能引用外部 reified 类型参数。
概念解释
reified 类型在展开点确定,函数内创建的匿名对象不持有类型参数副本。把 T::class 存入对象后,脱离内联上下文无法继续按 T 操作。
原理流程
- inline 函数展开处确定 T。
- 匿名类实例在展开代码内创建。
- 匿名类内部不能把 T 作为泛型实参保留。
- 长期保存需显式传入类型令牌对象。
代码或图示
inline fun <reified T> listener(): Any {
return object : EventListener {
override fun onEvent(e: Any) {
// 此处不能把外部 T 作为持久泛型类型使用
}
}
}
常见误区
- 期待匿名类成为
SomeClass<T>并保留 reified 实参:擦除与作用域均不支持。 - 把
T::class当作可序列化类型标记长期存储:脱离展开点语义失效。
追问
- 答:需要长期类型信息怎么办?答:构造对象时传入
KClass<T>作为字段保存。 - 答:反射在匿名类上能读到什么?答:擦除后的匿名类类型,读不到外部 reified 实参。
04.8.1.3-079 与 Java 8+ 对比:默认方法/静态方法与扩展函数有何差异?
一句话结论
Java 接口默认方法与静态方法属于类型本身,可被实现/继承;Kotlin 扩展是外部静态函数,不写入原类,静态解析、不参与多态。
概念解释
Java 8 用默认方法给接口提供通用实现,静态方法挂在接口上;Kotlin 扩展在不改原类的前提下补充工具方法。两者复用机制不同:成员属于类型,扩展属于外部工具层。
原理流程
- Java 默认方法进入接口实现表,子类可覆盖。
- Java 静态方法通过接口名调用。
- Kotlin 扩展编译为静态工具函数。
- 扩展不参与虚分派,Java 侧不可见。
代码或图示
// Kotlin 扩展:外部补充
fun List<String>.joined(): String = joinToString(",")
// 对比 Java 接口默认方法:实现类直接继承并可覆盖
常见误区
- 把扩展当作 Java 默认方法的等价物:分发与归属不同。
- 期待扩展被 Java 实现类继承:不存在继承关系。
追问
- 答:Kotlin 接口能有默认方法吗?答:可以,接口成员提供默认实现,属于类型成员,与扩展不同。
- 答:静态工具在 Kotlin 如何组织?答:顶层函数/伴生对象/扩展,按互操作需要选注解暴露。
04.8.1.3-080 与 Java 对比:泛型通配符与型变声明有何差异?
一句话结论
Java 在使用点用 ? extends/? super 逐处声明型变;Kotlin 在声明点用 out/in 定义接口子类型规则,调用方自动获得兼容关系。
概念解释
两侧型变方向一致:生产者协变、消费者逆变。区别在声明位置:Kotlin 一次定义,多处复用;Java 每个签名临时放宽。互操作时两侧投影类型相互映射。
原理流程
- Kotlin 接口声明
Producer<out T>。 - 所有使用点按协变规则判断兼容。
- Java 方法签名写
List<? extends T>。 - 互操作映射为对应投影类型。
代码或图示
// Kotlin 声明点
interface Source<out T> { fun next(): T }
// Java 使用点:List<? extends Number>
常见误区
- 把 Java 通配符写法照搬到 Kotlin 类声明:型变位置不同。
- 忽略声明点型变对所有调用方的约束影响。
追问
- 答:Kotlin 有没有使用点通配符?答:有类型投影与星投影作为使用点机制,核心型变仍在声明点。
- 答:两侧不变类型规则一致吗?答:一致,读写并存时固定实参,不构成子类型兼容。
04.8.1.3-081 与 Java 对比:高阶函数内联与 Lambda 元工厂有何差异?
一句话结论
Java lambda 编译为函数式接口实例(元工厂/ invokedynamic 生成),运行时存在函数对象;Kotlin inline 把 lambda 体展开到调用点,消除闭包对象分配。
概念解释
Java 8+ 通过 invokedynamic 在运行时生成函数实现;Kotlin 普通函数类型同样有对象表示,inline 是编译期消除手段。两者都支持简洁回调语法,对象生命周期与分发机制不同。
原理流程
- Java lambda:函数式接口实例由运行时机制生成。
- Kotlin 普通高阶函数:函数类型对象传入。
- Kotlin inline:体展开到调用点,无函数对象。
- 互操作时 Kotlin 函数类型映射为 Java 函数式接口。
代码或图示
inline fun <T> use(block: () -> T): T = block()
// 展开后无独立 lambda 对象;对比 Java 中 Runnable/Consumer 实例
常见误区
- 以为 Kotlin 所有 lambda 都无对象:仅 inline 参数消除。
- 把 Java invokedynamic 与 Kotlin 内联混为同一优化:阶段不同。
追问
- 答:Kotlin 函数类型在 Java 侧映射什么?答:按函数式接口或函数引用类呈现,详见互操作章节。
- 答:内联在跨语言边界生效吗?答:inline 是 Kotlin 编译期机制,跨 JVM 调用按生成签名处理。
04.8.1.3-082 Kotlin 2.x 中 inline、reified 与泛型有哪些需要确认的现状?
一句话结论
inline 与 reified 是稳定核心机制;contracts 自定义语法、部分泛型推断与互操作投影细节可能随版本演进,具体行为必须在项目编译版本上验证,不编造版本号。
概念解释
回答版本相关问题时区分稳定特性与演进特性。基线为 Kotlin 2.x、JDK 17+;新语法默认开关、标准库 API 状态、编译器诊断变化以官方文档与实测为准。
原理流程
- 记录编译器与标准库版本。
- 查官方文档特性稳定状态。
- 最小工程编译验证语法、诊断与投影行为。
- 不确定点标注「待确认」与验证步骤。
代码或图示
// 待确认:目标版本对 contracts 自定义声明、泛型投影导出的行为
// 验证点:编译工程观察诊断信息、字节码签名与标准库 API 是否存在
常见误区
- 把预览特性写成 2.x 稳定默认行为。
- 混淆语言版本、标准库版本与编译器插件版本。
追问
- 答:在哪里查特性状态?答:kotlinlang.org 官方文档与更新日志,结合工程编译实测。
- 答:待确认答案应包含什么?答:不确定行为点、验证命令与预期观察结果。
04.8.1.3-083 面试手写:写一个 reified 内联工具函数
一句话结论
声明 inline fun <reified T>,函数内用 T::class 或 is T 做类型判断,返回按 T 类型处理的结果;能说明 reified 依赖 inline 展开保留类型。
概念解释
评分点:inline 修饰、reified 参数、类型判断用法、返回类型与调用示例。补充说明非 inline 不能用 reified,以及擦除后容器元素类型不可恢复。
原理流程
- 写 inline 函数与 reified 类型参数。
- 函数内访问
T::class/is T。 - 调用处推断或显式指定实参。
- 说明运行时类对象来自编译期展开。
代码或图示
inline fun <reified T> List<Any>.findType(): T? =
firstOrNull { it is T } as? T
val items: List<Any> = listOf(1, "two", 3L)
val ints: List<Int> = items.findType<Int>()?.let { listOf(it) } ?: emptyList()
常见误区
- 函数漏写 inline:reified 报错。
- 用 reified 判断泛型容器元素类型:擦除后不可得。
追问
- 答:
T::class返回什么类型?答:KClass<T>,可.java转 JVM Class。 - 答:未检查强转如何标注?答:校验后使用,按编译器抑制规则说明安全前提。
04.8.1.3-084 面试手写:为自定义类型写扩展函数
一句话结论
按 fun Receiver.method(args): ReturnType 声明,函数体用 this 访问接收者;给出调用示例,并说明扩展是静态解析、不写入原类。
概念解释
评分点:接收者类型、this 使用、可见性、调用语法。可对比成员方法:扩展不参与多态,Java 侧不可见。
原理流程
- 确定接收者类型与操作职责。
- 声明扩展函数,体内访问
this。 - 调用处
receiver.method(args)。 - 说明编译为静态工具函数。
代码或图示
data class Money(val amount: Long, val currency: String)
fun Money.format(): String = "${currency} ${amount}"
fun main() {
val m = Money(100, "CNY")
println(m.format())
}
常见误区
- 扩展内访问接收者私有成员:不可见。
- 把扩展写进原类当作成员方法:归属不同。
追问
- 答:扩展属性怎么写?答:
val Receiver.prop: Type get() = ...,无幕后字段。 - 答:同名成员与扩展谁优先?答:成员方法优先。
04.8.1.3-085 面试手写:判断型变标注是否正确并修正
一句话结论
先列接口方法中 T 出现的位置:只返回标 out,只消费标 in,读写并存保持不变;发现协变接口写入方法或逆变接口返回值即判错并修正。
概念解释
评分点:型变方向判断、位置检查、编译约束理解。给出错误标注案例与修正后接口,说明外部赋值兼容关系。
原理流程
- 列出每个方法的参数与返回类型。
- 判断 T 是生产者还是消费者。
- 错误标注违反位置约束时编译报错。
- 修正为对应型变或拆分接口。
代码或图示
// 错误:out 接口包含写入方法
interface Bad<out T> {
fun add(item: T) // 编译报错
fun get(): T
}
// 修正:只保留生产者方法
interface Good<out T> { fun get(): T }
常见误区
- 把读写接口强行标 out/in:应拆分只读与可变接口。
- 忽略标准库 List out、MutableList 不变的范例。
追问
- 答:
MutableList<T>为什么不变?答:同时读取与写入,T 出现在两种位置。 - 答:逆变接口返回 T 为什么报错?答:消费者不能产出 T,返回位置违反逆变约束。
04.8.1.3-086 面试手写:写一个最小 DSL 构建器
一句话结论
定义根类与子节点类,根函数接收者 lambda 创建根实例,子方法创建子节点并绑定子接收者;最终返回不可变配置对象。
概念解释
评分点:接收者 lambda、嵌套绑定、子节点加入容器、不可变返回。可补充 DslMarker 防止跨层误访问。
原理流程
- 声明配置数据类。
- 根构建函数
block: Root.() -> Unit。 - 子工厂方法创建子对象、加入列表、apply 内层 lambda。
- 返回根配置实例。
代码或图示
data class Item(val name: String)
data class Bag(val items: List<Item> = emptyList())
class BagBuilder {
private val items = mutableListOf<Item>()
fun item(name: String) { items.add(Item(name)) }
fun build() = Bag(items)
}
fun bag(block: BagBuilder.() -> Unit): Bag =
BagBuilder().apply(block).build()
val myBag = bag {
item("book")
item("pen")
}
常见误区
- 构建函数返回内部可变 builder:外部可改结构。
- 子节点方法忘记加入父容器:树结构断裂。
追问
- 答:如何加必填校验?答:build() 阶段检查必填项,缺失抛配置异常。
- 答:DslMarker 怎么加?答:定义标记注解并标注根与子 builder 类型。
04.8.1.3-087 面试手写:解释 noinline/crossinline 编译报错
一句话结论
按报错位置区分:参数修饰冲突看声明处,非局部 return 看 lambda 体;noinline 保留对象,crossinline 禁止非局部返回,按语义选择修正方式。
概念解释
答题先复述诊断含义,再判断修饰符是否用错:需要存储 lambda 对象用 noinline,lambda 被内部对象/回调调用用 crossinline,其余默认内联。
原理流程
- 定位报错在参数声明还是 lambda 体内。
- 检查修饰组合是否合法。
- crossinline 体内裸 return 改为标签返回。
- noinline 参数不参与内联展开上下文。
代码或图示
inline fun outer(crossinline cb: () -> Unit) {
val runner = object : Runnable { override fun run() = cb() }
runner.run()
}
// cb 内若写 return 外层函数:报错;改为 return@outer 标签返回
常见误区
- 把 crossinline 当 noinline 用:对象仍内联。
- 在 noinline 参数上要求 reified 式展开:机制不支持。
追问
- 答:什么场景必须 crossinline?答:内联参数传给内部类实例、注册到回调或另一异步上下文。
- 答:报错如何修复后验证?答:重新编译确认诊断消失,并检查 lambda 返回行为符合预期。
04.8.1.3-088 泛型上下界实战:如何约束 T 可比较?
一句话结论
声明 T : Comparable<T>,函数体内即可调用 compareTo、比较运算符与排序工具;需要同时满足其他接口时按多界约束补充。
概念解释
上界把类型参数限制在可比较类型范围内,编译器允许调用上界接口方法。常见于最值、排序、区间判断工具函数。
原理流程
- 类型参数声明上界
Comparable<T>。 - 实参必须实现该接口。
- 函数体内按上界类型调用成员。
- 调用方传入满足约束的类型。
代码或图示
fun <T : Comparable<T>> minOf(a: T, b: T): T = if (a <= b) a else b
data class Product(val price: Int) : Comparable<Product> {
override fun compareTo(other: Product) = price.compareTo(other.price)
}
常见误区
- 上界不足却调用比较方法:编译报错。
- compareTo 与 equals 方向不一致:排序与判等矛盾。
追问
- 答:多上界怎么写?答:按 where 子句或冒号组合声明,具体语法以官方文档为准。
- 答:T 可空时比较如何处理?答:上界收紧为
Any或在函数内判空后比较。
04.8.1.3-089 扩展属性实战:为类型派生字段
一句话结论
在接收者类型上声明只读扩展属性,getter 从接收者状态派生计算;无幕后字段,每次访问重新计算,适合展示型派生值。
概念解释
评分点:扩展属性语法、getter 实现、无字段约束。派生属性不保存状态,依赖接收者公开可见状态;可变扩展属性需在接收者状态上落地修改。
原理流程
- 声明
val Receiver.prop: Type。 - getter 内读取
this状态计算。 - 访问属性触发 getter。
- 不存储独立字段。
代码或图示
data class Order(val items: List<Int>)
val Order.total: Int get() = items.sum()
val Order.itemCount: Int get() = items.size
常见误区
- 给扩展属性赋初始值:无字段不允许。
- 派生属性内做重计算缓存:缓存应放在接收者类或委托中。
追问
- 答:扩展属性能有 setter 吗?答:可以声明
var,setter 修改接收者可见状态,仍无独立字段。 - 答:扩展属性与成员属性冲突谁优先?答:成员属性优先。
04.8.1.3-090 契约实战:contract 如何帮助 smart cast?
一句话结论
校验函数通过契约声明「返回后参数非空/类型匹配」,编译器在调用点后收窄变量类型;无契约时外部变量在 lambda/函数边界后不被智能转换。
概念解释
实战中常用 requireNotNull、checkNotNull 一类标准库函数获得穿透转换。自定义契约语法与稳定范围按版本确认,不确定处用显式判空兜底。
原理流程
- 高阶/校验函数接收变量并内部检查。
- 契约把检查结论告知编译器。
- 调用点后变量类型收窄。
- 后续代码按收窄类型访问成员。
代码或图示
fun <T : Any> T?.checked(): T =
this ?: throw IllegalArgumentException("required")
fun demo(name: String?) {
val n = name.checked()
println(n.length) // 依赖契约/标准库实现完成收窄
}
常见误区
- 以为普通函数自动传递判空结论:需要契约支持。
- 把契约当运行时检查:运行时仍需抛异常兜底。
追问
- 答:契约不可用时怎么写?答:
if (x != null)判空、?:兜底或读入局部变量收窄。 - 答:标准库哪些函数带契约?答:
requireNotNull、checkNotNull等,具体清单以版本文档为准。
04.8.1.3-091 操作符实战:为自定义类型实现 +
一句话结论
声明 operator fun plus(other: T): T,返回新组合实例;+ 表达式编译为 plus 调用,语义应与加法直觉一致,不可变对象返回新实例。
概念解释
评分点:operator 修饰、约定方法名、参数返回类型、不可变返回。可扩展到 minus、times 等对应约定,保持操作符含义清晰。
原理流程
- 类型声明 plus 约定方法。
- 方法内组合两个实例字段。
- 返回新实例,不修改原对象。
a + b解析为a.plus(b)。
代码或图示
data class Point(val x: Int, val y: Int) {
operator fun plus(other: Point) = Point(x + other.x, y + other.y)
}
val p = Point(1, 2) + Point(3, 4)
常见误区
- 漏掉
operator:+不可用。 - 操作符修改原对象:违背不可变与直觉语义。
追问
- 答:
+=走哪个约定?答:plus 复合赋值语义,可变对象也可实现 plusAssign,规则以官方文档为准。 - 答:操作符返回类型必须与接收者相同吗?答:约定允许兼容类型,按语义设计。
04.8.1.3-092 中缀实战:实现领域可读语法
一句话结论
为单参数领域方法加 infix,调用写成 a 方法 b;仅在语义自然、可读性提升时使用,参数固定一个,普通点号调用仍可用。
概念解释
中缀适合关系型领域表达:归属、匹配、组合。设计时确认方法名读起来像领域谓词;业务逻辑复杂或多参数时退回普通方法。
原理流程
- 声明
infix fun Receiver.method(other: T): R。 - 调用
receiver method other。 - 编译器解析为方法调用。
- 语义不清时用点号形式。
代码或图示
data class User(val roles: Set<String>)
infix fun User.has(role: String): Boolean = role in roles
val admin = User(setOf("admin", "user"))
if (admin has "admin") { println("ok") }
常见误区
- 多参数方法强行中缀:语法受限。
- 领域谓词命名晦涩:中缀可读性反而下降。
追问
- 答:中缀函数可以是扩展吗?答:可以,成员或扩展单参数函数均可加 infix。
- 答:标准库
to是什么?答:infix 扩展,构造Pair。
04.8.1.3-093 集合型变实例:为什么 List<String> 能赋给 List<Any>?
一句话结论
List<out E> 是协变生产者,只读取元素不提供写入方法;String 是 Any 子类型,因此 List<String> 兼容 List<Any>,读取时按 Any 使用。
概念解释
协变安全的前提是没有写入位置:只读接口不能把外部传入的任意 Any 塞回列表。MutableList 有 add/set,因此不变,不能这样赋值。
原理流程
List<out E>声明元素只在返回位置出现。String <: Any,子类型实参可替换。- 赋值后读取元素为
Any类型。 - 尝试写入会被编译器拒绝。
代码或图示
val strings: List<String> = listOf("a", "b")
val anys: List<Any> = strings // 协变兼容
val mut: MutableList<String> = mutableListOf()
// val mAny: MutableList<Any> = mut // 不兼容
常见误区
- 把只读集合协变结论套到可变集合:写入位置破坏安全。
- 协变列表里尝试添加元素:编译受限。
追问
- 答:读取
List<Any>元素还能当 String 用吗?答:需要as?或 smart cast 收窄。 - 答:Set 型变规则?答:
Set<out E>同理协变只读。
04.8.1.3-094 函数类型的型变如何标注?
一句话结论
函数参数位置是逆变(in T 方向),返回位置是协变(out T 方向);(T) -> R 中参数 T 逆变、返回 R 协变,函数类型子类型关系按此推导。
概念解释
能接受更宽参数的函数可替代窄参数函数(逆变),返回更具体类型的函数可替代宽返回函数(协变)。标准库函数类型已按此型变规则定义。
原理流程
- 函数类型参数位置:消费者,逆变。
- 返回位置:生产者,协变。
- 子类型替换按两个方向分别检查。
- 高阶函数参数按函数类型型变兼容判断。
代码或图示
// (Any) -> Unit 可赋值给 (String) -> Unit(参数逆变)
val consumeAny: (Any) -> Unit = { println(it) }
val consumeString: (String) -> Unit = consumeAny
常见误区
- 把参数位置当协变方向:方向相反。
- 忽略函数返回值协变:具体返回函数可替代宽返回。
追问
- 答:函数类型与 SAM 接口型变一致吗?答:函数式接口按参数/返回位置同样遵循逆变协变规则。
- 答:型变冲突在编译期哪里报错?答:赋值或传参的函数类型不兼容位置。
04.8.1.3-095 泛型缓存与类型擦除后序列化有哪些注意点?
一句话结论
擦除后容器不保存元素类型,序列化/反序列化必须显式携带类型令牌或使用支持泛型的序列化器;缓存键与类型判断不能依赖运行时泛型实参。
概念解释
缓存按键查找时,泛型实参不在运行时可见。序列化框架需通过 TypeReference、KClass 或 reified 扩展恢复嵌套类型;普通 Class 无法表达泛型实参。
原理流程
- 序列化时保存目标类型信息(令牌/泛型描述)。
- 反序列化按保存类型重建对象。
- 缓存键不含泛型实参,必要时把类型令牌纳入键。
- 运行时
is只能判断外层类型。
代码或图示
// 序列化库通常要求显式泛型类型标记;reified 扩展在编译期携带外层类型
inline fun <reified T> decode(raw: String): T? = /* 库类型化 API */ null
常见误区
- 依赖容器运行时恢复元素泛型:擦除不可得。
- 缓存不同泛型实参共用键而不区分类型:取值强转出错。
追问
- 答:嵌套泛型如何携带类型?答:库支持的泛型序列化器/类型令牌,普通 Class 不够。
- 答:反序列化失败如何排查?答:核对类型令牌、库版本与字段可空性,补充类型化测试。
04.8.1.3-096 扩展在模块分层中应使用在什么边界?
一句话结论
扩展适合补充同类型工具操作,按模块内可见性组织;跨模块公开扩展需评估 API 稳定性,避免在核心领域类型上堆叠外部扩展造成调用困惑。
概念解释
模块分层中,扩展可放在工具层补充领域类型操作;领域核心行为应留在类/接口内。扩展可见性按 private/internal/public 控制,跨模块公开属于 API 承诺。
原理流程
- 判断操作属于类型核心行为还是外部工具。
- 核心行为写成员/接口方法。
- 工具操作按接收者类型聚合扩展文件。
- 跨模块公开扩展纳入 API 兼容审查。
代码或图示
// 模块内工具扩展
internal fun Order.receiptText(): String = /* ... */
常见误区
- 在领域核心类上挂大量跨模块扩展:调用方发现路径分散。
- 内部辅助扩展误标 public:API 面扩大。
追问
- 答:扩展与领域服务如何分工?答:无依赖的纯类型操作用扩展;有跨实体依赖与副作用的逻辑放服务类。
- 答:公开扩展兼容注意什么?答:接收者类型演进会影响扩展签名,修改需评估 ABI。
04.8.1.3-097 DSL 安全性:编译期约束与运行期校验如何分工?
一句话结论
类型与结构合法性由编译期保证(方法存在、接收者类型、DslMarker 作用域);业务规则(必填项、取值范围、交叉约束)必须在运行期校验。
概念解释
DSL 语法正确不等于业务配置合法。编译期拦截结构错误,运行期校验语义约束;构建完成返回前统一检查,非法配置尽早失败。
原理流程
- 编译期:类型检查、接收者解析、标记作用域。
- 构建期:收集节点与参数。
- 运行期:校验必填、范围、关联一致性。
- 校验失败抛配置异常,不返回半成品对象。
代码或图示
class Builder {
var host: String? = null
fun build(): Server {
requireNotNull(host) { "host 必填" }
return Server(host!!)
}
}
常见误区
- 以为 DSL 类型安全覆盖业务校验:结构合法不代表配置合法。
- 校验分散在各节点:最终一致性难以保证。
追问
- 答:运行期校验放哪里?答:build/finalize 阶段统一检查,或领域对象构造期校验。
- 答:编译期能检查必填项吗?答:构造参数必填可编译期约束;可选后补项需运行期检查。
04.8.1.3-098 内联函数进入公共 API 有什么 ABI 兼容风险?
一句话结论
inline 函数体被复制到调用方字节码,后续修改内联实现会影响已编译调用方;公共 API 中的 inline 成员变更需要谨慎评估二进制兼容。
概念解释
普通库函数调用在运行时绑定,升级库替换实现即可;inline 函数逻辑已展开进调用方,库升级不会自动更新调用方字节码。公共库设计应区分内联工具与稳定 API。
原理流程
- 调用方编译时复制 inline 函数体。
- 库后续修改内联实现。
- 已编译调用方仍保留旧展开代码。
- 行为不一致,二进制兼容风险产生。
代码或图示
// 公共库中:修改 inline fun 体不会自动更新已编译调用方
inline fun clamp(v: Int, max: Int): Int = v.coerceAtMost(max)
常见误区
- 把所有公共高阶函数标 inline:ABI 灵活性下降。
- 升级库后观察不到 inline 行为变化:调用方需重新编译。
追问
- 答:哪些 inline 适合公开 API?答:短小稳定、不随版本调整实现的工具函数。
- 答:reified 公共函数同样受影响吗?答:类型保留依赖展开,ABI 风险与 inline 机制一致。
04.8.1.3-099 泛型与子类型规则如何总结?
一句话结论
非空是可空子类型,Nothing 是万物子类型;泛型默认不变,生产者 out 协变、消费者 in 逆变;赋值兼容沿子类型方向,收窄需类型检查或断言。
概念解释
规则分三层:基础类型层级、泛型型变、函数型变。编译器在赋值、传参、返回位置检查兼容;擦除后运行时只保留外层类型。
原理流程
- 基础类型按
Any?/Any/具体类型/Nothing层级判断。 - 泛型实参按 out/in/不变规则判断兼容。
- 函数类型参数逆变、返回协变。
- 不兼容时编译报错,收窄需显式检查。
代码或图示
val any: Any = "text" // String <: Any
val list: List<Any> = listOf("a") // List<String> <: List<Any>(协变)
常见误区
- 忽略型变把可变集合当协变使用。
- 运行时按泛型实参做子类型判断:擦除受限。
追问
- 答:星投影在规则中处于什么位置?答:未知实参的安全投影,读取按上界、写入受限。
- 答:子类型检查失败如何修复?答:调整型变标注、拆分接口或显式类型收窄。
04.8.1.3-100 本页知识如何串联构成 Kotlin 表达力?
一句话结论
泛型提供类型安全复用,扩展在不改原类前提下补充工具,inline 消除高阶函数开销并保留 reified 类型,DSL 与约定语法把组合逻辑表达为领域声明式代码。
概念解释
四类机制相互配合:泛型约束类型参数,扩展挂接工具方法,内联支撑高阶函数与类型保留,约定与 DslMarker 组织可读结构。理解组合方式才能在工程中选型而不是堆叠语法。
原理流程
- 用泛型抽象复用逻辑并标注型变。
- 用扩展为类型补充工具操作。
- 高频高阶函数 inline,需要类型判断时 reified。
- 配置/层级结构用 DSL 接收者与标记组织。
代码或图示
inline fun <reified T> List<*>.toTyped(): List<T> = filterIsInstance<T>()
infix fun <T> List<T>.orElse(default: List<T>): List<T> =
if (isEmpty()) default else this
常见误区
- 为炫技堆叠扩展、DSL 与内联:可读性与兼容成本上升。
- 脱离场景选型:核心行为应留在类型成员内。
追问
- 答:本页哪些概念在集合章节继续?答:型变集合接口、Sequence 惰性链、作用域函数。
- 答:哪些在互操作章节继续?答:通配符映射、函数类型接口转换、扩展 Java 可见性。
参考来源
- Kotlin 官方文档:Generics — 泛型、型变、上界与星投影。
- Kotlin 官方文档:Extensions — 扩展函数与扩展属性机制。
- Kotlin 官方文档:Inline Functions — inline、noinline、crossinline 与 reified。
- Kotlin 官方文档:Type-Safe Builders — DSL 构建器与接收者 lambda。
- Kotlin 官方文档:Operator Overloading — 操作符、中缀与约定方法。
待整理清单
- [ ] 在项目 Kotlin 2.x 版本上核对 contracts 自定义语法的稳定状态与诊断行为
- [ ] 核对 Java 通配符与 Kotlin 投影互操作导出签名的实测结果
- [ ] 补充 reified 序列化辅助与目标序列化库版本兼容性记录
- [ ] 整理 inline 公共 API 的 ABI 兼容审查清单与示例