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

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 携带类型参数。

概念解释

类型参数用尖括号声明,作用域限定在对应声明内。泛型函数的类型参数只对该函数有效,不依赖类级参数;属性泛型较少见,主要用于派生属性类型。

原理流程

  1. 类名后声明 <T>,类体与构造器使用 T。
  2. 函数名前声明 <T>,参数与返回类型引用 T。
  3. 属性声明类型参数并在访问器类型中使用。
  4. 调用/实例化时传入实参或由编译器推断。

代码或图示

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 历史兼容机制:字节码不保存类型实参信息。编译器在编译期做类型检查,插入必要的强转;运行时无法仅凭容器区分泛型实参。

原理流程

  1. 编译期按泛型签名检查类型兼容。
  2. 字节码中类型参数替换为上界类型。
  3. 取值点插入类型转换指令。
  4. 反射与 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 作为参数(消费者),可以逆变。

原理流程

  1. 分析类型参数在接口中的位置:返回位置还是参数位置。
  2. 生产者用 out T,允许子类型实参替换。
  3. 消费者用 in T,允许父类型实参替换。
  4. 同时读写则保持不变。

代码或图示

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> 就是协变生产者,元素只被读取不被修改。

原理流程

  1. 接口方法中 T 只出现在返回类型。
  2. 声明 out T 后编译器禁止 T 出现在消费参数位置。
  3. 子类型实参可替换父类型实参。
  4. 赋值与传参按协变规则兼容。

代码或图示

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 的参数位置就是逆变位置。

原理流程

  1. 接口方法中 T 只出现在参数类型。
  2. 声明 in T,编译器禁止 T 作为返回值。
  3. 父类型实参可替换子类型实参。
  4. 调用方传入子类型实参被消费接口接受。

代码或图示

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> 同时读取与写入,因此是不变的。

原理流程

  1. 类型参数同时出现在读写位置。
  2. 编译器不允许声明型变。
  3. 赋值检查要求实参类型完全匹配。
  4. 需要协变/逆变时拆分只读与可变接口。

代码或图示

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 也支持使用点投影(星投影与类型投影),但核心型变在声明处表达。

原理流程

  1. Kotlin 接口声明 Producer<out T>。
  2. 所有使用点自动按协变规则判断兼容。
  3. Java 方法签名用 List<? extends T> 临时协变。
  4. 互操作时 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<*> 当作只读安全视图,不能向其中写入任意值,读取得到上界类型;它是处理未知实参的安全退路。

概念解释

* 等价于带上下界的投影:产出位置按上界读取,消费位置禁止写入具体值。星投影不改变擦除事实,只是在编译期提供安全使用边界。

原理流程

  1. 编译器把 * 展开为带边界的类型投影。
  2. 读取元素:返回上界类型(如 Any?)。
  3. 写入元素:实参未知,禁止传入具体值。
  4. 需要精确类型时通过 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?;有类上界时读取位置按该上界暴露。星投影不绕过界约束。

原理流程

  1. 查看类型参数声明的上界。
  2. 星投影读取位置映射为上界类型。
  3. 写入位置按未知实参禁止具体写入。
  4. 下界约束(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> 表达「自身可与自身比较」。多界约束让类型同时满足类与接口要求。

原理流程

  1. 类型参数声明后接冒号与上界类型。
  2. 实参必须是上界类型的子类型。
  3. 函数体内可按上界类型调用成员。
  4. 多个边界按语法组合声明。

代码或图示

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?。

原理流程

  1. 未写上界:T : Any?,实参可空。
  2. 显式 T : Any:实参必须非空。
  3. 函数体内按上界可空性做安全检查。
  4. 传入可空实参给 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 与枚举自类型场景;编译器据此在基类方法中返回或接受派生类型。

原理流程

  1. 声明 T : SelfInterface<T>。
  2. 实参传入派生类型自身。
  3. 基类方法可按 T 类型返回或比较。
  4. 不满足递归约束的实参被拒绝。

代码或图示

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 常显式写实参以保证签名可读;局部调用依赖推断即可。

原理流程

  1. 收集各实参表达式候选类型。
  2. 结合返回值目标类型收窄。
  3. 唯一候选则确定实参。
  4. 歧义或不足时显式 <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 类型参数由内联机制保留:函数体在调用点展开,实参类型随编译期上下文进入。

原理流程

  1. 普通泛型:字节码擦除 T,运行时无类对象。
  2. 声明 inline fun <reified T>。
  3. 编译期记录实参类型,函数体展开到调用点。
  4. 函数内可访问 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 判断。

概念解释

内联消除了函数调用边界,类型参数不再经过运行时擦除传递。编译器把实参类型写进展开代码,运行时判断基于具体类型完成。

原理流程

  1. 编译器识别 inline 函数与 reified 参数。
  2. 每个调用点替换为函数体代码。
  3. reified 实参类型在展开处确定并保留。
  4. 函数内 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。

原理流程

  1. 检查函数是否 inline:否则拒绝 reified。
  2. reified 参数只在该函数体作用域可用。
  3. 不能把 reified 类型参数存入运行时泛型容器做擦除后判断。
  4. 跨内联边界传递受编译器规则限制。

代码或图示

// 非法:非 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 扩展、事件总线按类型订阅。底层仍是编译期类型携带,运行时做具体类型匹配。

原理流程

  1. 调用处传入目标类型(显式或推断)。
  2. 内联展开保留 T。
  3. 函数内 is T/T::class 做判断与反射。
  4. 结果按 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 判断实例归属。

原理流程

  1. 普通泛型函数内写 is T:编译报错。
  2. 方案一:参数接收 KClass<T>,调用 isInstance。
  3. 方案二:函数改 inline + reified,编译期保留类型。
  4. 反射判断结果按令牌类型返回。

代码或图示

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 判断原本元素实参。序列化与持久化需另外保存元素类型。

原理流程

  1. 编译后容器元素类型擦除。
  2. 类对象为原始 List 类型。
  3. 反射读取不到类型实参。
  4. 需要元素类型时由数据结构显式保存令牌。

代码或图示

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 单方法接口在互操作边界适配为函数调用。

原理流程

  1. 泛型函数声明函数类型参数 (T) -> Unit。
  2. 调用 lambda,编译器按 T 推断参数类型。
  3. Java SAM 接口场景生成接口实现实例。
  4. 泛型实参在接口实现上保持约束。

代码或图示

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 访问接收者实例;它不修改原类,只是在调用点提供语法糖。

概念解释

扩展用于为已有类型补充工具方法,无需继承或改造源码。声明包含接收者类型、函数名、参数列表与函数体;可声明为顶层、类内或局部扩展。

原理流程

  1. 写 fun Receiver.method(args): ReturnType。
  2. 函数体内 this 绑定接收者实例。
  3. 编译为静态函数,第一个参数为接收者。
  4. 调用点 receiver.method(args) 语法转发。

代码或图示

fun String.hasPrefix(): Boolean = this.startsWith("kotlin")

val s = "kotlin-lang"
println(s.hasPrefix())

常见误区

  • 以为扩展会向原类写入方法:原类字节码不变。
  • 扩展访问接收者私有成员:扩展只能访问公开/可见成员。

追问

  • 答:扩展函数可以是顶层的吗?答:可以,顶层扩展编译到文件包装类。
  • 答:局部扩展作用域?答:只在声明它的函数/块内可见。

04.8.1.3-022 扩展函数为什么是静态解析,不参与多态?

一句话结论

扩展在编译期按接收者声明类型解析,不是虚方法分发;接收者实际类型替换不会改变调用的扩展版本,因此不能通过扩展覆写父类方法。

概念解释

扩展不是类成员,没有进入虚方法表。编译期根据变量/表达式的静态类型选择扩展函数;运行时对象替换不触发多态分派。同名成员方法优先于扩展。

原理流程

  1. 编译期识别接收者静态类型。
  2. 查找该类型可见的扩展函数。
  3. 生成静态调用,传入接收者参数。
  4. 运行时不按实际类型重新选择扩展。

代码或图示

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,值由接收者状态派生。

概念解释

扩展属性是访问器语法糖,没有独立存储。不能初始化字段,不能直接持有状态;常用于派生只读字段,如集合派生属性。

原理流程

  1. 声明 val Receiver.prop: Type get() = ...。
  2. 编译器生成静态访问器方法。
  3. 每次访问从接收者状态计算。
  4. 可变扩展属性 setter 也转发为静态方法。

代码或图示

val String.lastChar: Char
    get() = this[this.length - 1]

val "kotlin".lastChar

常见误区

  • 给扩展属性赋初始值:无幕后字段,不允许。
  • 期望扩展属性保存跨调用状态:状态应放在原类或包装类。

追问

  • 答:扩展属性可以有 setter 吗?答:可以,声明 var 并实现 get/set,set 内修改接收者可见状态。
  • 答:扩展属性与委托属性冲突吗?答:可组合,但委托状态仍不存储在扩展属性字段中。

04.8.1.3-024 顶层扩展与成员方法的优先级如何解析?

一句话结论

同名调用时成员方法优先于扩展函数;扩展按接收者类型可见性与导入顺序解析,多个候选冲突时编译器要求显式消歧。

概念解释

成员属于类本身,解析优先级最高。扩展是外部补充,在成员缺失时参与候选。导入不同包的同名扩展可能造成歧义,需要限定调用或调整导入。

原理流程

  1. 先检查接收者类型是否有同名成员方法。
  2. 成员存在:调用成员方法。
  3. 成员缺失:查找可见扩展函数。
  4. 多扩展候选:按类型匹配度与规则选择,歧义时报错。

代码或图示

class ListHolder {
    fun size() = 10 // 成员优先
}

fun ListHolder.size(): Int = 20 // 扩展不覆盖成员

常见误区

  • 定义扩展试图覆盖已有成员:不会生效。
  • 导入多个同名扩展导致调用歧义:按诊断限定接收者或导入。

追问

  • 答:扩展函数可见性由什么控制?答:声明可见性与导入作用域,未导入不可见。
  • 答:同类型多个扩展谁生效?答:匹配更具体的类型优先,歧义由编译器报错提示。

04.8.1.3-025 如何定义允许空接收者的扩展函数?

一句话结论

把接收者类型声明为可空 Receiver?,函数体内自行判空处理;非空接收者扩展不能在 null 上调用。

概念解释

标准库 orEmpty 一类扩展即空接收者扩展。声明接收者 T? 后,函数内 this 可能为空,需要 ?. 或判空分支。

原理流程

  1. 扩展声明接收者为 T?。
  2. 函数体读取可空 this。
  3. 为空时返回缺省值或处理分支。
  4. 调用方可在可空变量上直接调用该扩展。

代码或图示

fun String?.orBlank(): String = this ?: ""

val name: String? = null
println(name.orBlank())

常见误区

  • 在非空接收者扩展内直接解引用可空值:接收者类型不匹配。
  • 空接收者扩展不判空:函数体内触发空安全报错。

追问

  • 答:空接收者扩展与安全调用 ?. 关系?答:扩展内部处理空值,调用处可省略 ?.;非空扩展仍需安全调用。
  • 答:标准库哪些扩展允许空接收者?答:orEmpty、集合判空扩展等,按标准库文档核对。

04.8.1.3-026 扩展函数中接收者类型与 this 如何指向?

一句话结论

扩展函数体内 this 绑定接收者实例,类型为声明的接收者类型;在类内部扩展时,可能同时存在调度接收者与扩展接收者两个 this。

概念解释

普通函数 this 指向所在类实例;扩展函数的 this 指向被扩展对象。类内声明的扩展,外层类实例与扩展接收者需要用限定 this 消歧。

原理流程

  1. 顶层扩展:this 即接收者类型实例。
  2. 类内扩展:外层类为调度接收者,扩展类型为扩展接收者。
  3. 同名歧义时用 this@Outer 与 this@Receiver 限定。
  4. 编译为静态函数,接收者作为首参传入。

代码或图示

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@类名 显式区分。

概念解释

当扩展写在类体内时,函数同时属于外层类上下文与扩展类型上下文。解析成员时按两个接收者顺序查找,同名成员必须限定来源,避免歧义。

原理流程

  1. 外层类实例为调度接收者。
  2. 扩展类型实例为扩展接收者。
  3. 成员查找先匹配最近接收者。
  4. 冲突时用限定语法指定 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 限定边界。

原理流程

  1. 声明扩展时指定可见性修饰符。
  2. 顶层扩展在对应包内,调用方导入后使用。
  3. 类内扩展随外层类作用域。
  4. 未导入或越界不可见,编译报错。

代码或图示

// utils/Strings.kt
internal fun String.trimAll(): String = this.replace(" ", "")

常见误区

  • 以为标准库扩展随处可用:自定义扩展需导入。
  • 把跨模块内部扩展暴露给外部:internal 边界受限。

追问

  • 答:扩展可以 private 声明在文件内吗?答:可以,文件内私有辅助扩展。
  • 答:Java 侧能否看到 Kotlin 顶层扩展?答:编译为静态工具方法,按文件包装类访问,不是接收者类型成员。

04.8.1.3-029 泛型扩展与类型约束如何结合?

一句话结论

扩展函数可声明类型参数与上界,接收者类型也可参数化,如 List<T>.firstOrNull();约束决定扩展内可调用的接收者成员。

概念解释

泛型扩展兼顾复用与类型安全:接收者是泛型容器时,扩展内按类型参数边界访问元素。标准库大量集合扩展属于泛型扩展。

原理流程

  1. 扩展声明类型参数与接收者泛型类型。
  2. 上界约束元素可用成员。
  3. 函数体按泛型类型操作。
  4. 调用处推断实参类型。

代码或图示

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 代码的典型可读性特征;理解扩展机制才能区分标准库方法与自定义工具。

原理流程

  1. 核心类型保持基础实现。
  2. 扩展函数按场景补充操作。
  3. 调用方链式组合多个扩展。
  4. 编译期静态解析为对应静态调用。

代码或图示

val result = listOf(1, 2, 3)
    .filter { it > 1 }
    .map { it * 2 }
    .firstOrNull()

常见误区

  • 把标准库扩展当作原类自带方法记录源码结构:原类未写入这些方法。
  • 链式过长不拆分:可读性与调试性下降。

追问

  • 答:作用域函数也是扩展吗?答:let/run/apply/also 等是标准库顶层/扩展函数,详见集合与互操作章节。
  • 答:自定义扩展应放哪里?答:按领域聚合到工具文件,导入后复用,避免散落在业务类内。

04.8.1.3-031 扩展不能被覆写的典型案例是什么?

一句话结论

子类重写父类成员时,同名扩展不会被覆盖;按静态类型解析的扩展调用固定绑定声明类型,多态行为必须通过接口/继承实现。

概念解释

案例:父类与子类各有同名扩展,变量声明为父类时调用父类扩展,即使实际是子类实例。这与成员方法虚分派行为不同,是扩展静态解析的直接后果。

原理流程

  1. 定义开放父类与子类。
  2. 分别为两者写同名扩展。
  3. 父类型变量持有子类实例。
  4. 编译期按父类型解析扩展,运行时不切换。

代码或图示

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 与编译器会提示成员优先,扩展实际不可见地被遮蔽。

原理流程

  1. 编译期检查接收者静态类型的成员表。
  2. 匹配到同名成员:生成成员调用。
  3. 无成员:查找可见扩展函数。
  4. 多扩展候选按类型匹配与导入规则消歧。

代码或图示

class Box {
    fun dump() = "member"
}
fun Box.dump() = "extension" // 被成员遮蔽

Box().dump() // member

常见误区

  • 定义扩展期望改变已有成员行为:无效。
  • 成员与扩展命名相近造成阅读混淆:命名应区分职责。

追问

  • 答:扩展能否调用被遮蔽的同名成员?答:通过限定或原类实例访问,扩展本身不覆盖成员。
  • 答:解析歧义报错如何修复?答:调整导入、显式限定接收者类型或重命名扩展。

04.8.1.3-033 inline 函数如何消除 lambda 运行时开销?

一句话结论

inline 把函数体展开到调用点,高阶函数传入的 lambda 不再编译为函数对象,避免每次调用创建 lambda 实例与间接调用开销。

概念解释

普通高阶函数接收函数类型参数,lambda 被包装为函数对象实例;内联后 lambda 代码并入调用点,闭包对象分配减少。代价是字节码体积随调用点复制增长。

原理流程

  1. 编译器标记 inline 函数。
  2. 每个调用点替换为函数体代码。
  3. lambda 体就地展开,不生成函数对象。
  4. 运行时无闭包分配与转发调用。

代码或图示

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 体也并入调用点,参数不再作为运行时函数对象传递。

概念解释

展开发生在编译期,调用点之间复制函数体。递归或无法内联的调用会回退为普通函数调用并给出诊断。理解展开位置有助于排查体积与调试信息问题。

原理流程

  1. 编译器扫描 inline 函数调用点。
  2. 函数体模板替换到调用处。
  3. 实参与 lambda 体按规则代入。
  4. 无法内联的结构(如递归)生成普通调用并提示。

代码或图示

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 保留对象形态。

原理流程

  1. inline 函数参数加 noinline。
  2. 编译器不为该参数展开 lambda 体。
  3. 参数作为函数类型对象传入函数体。
  4. 其余参数仍按 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 只能用标签返回。

原理流程

  1. inline 函数把参数 lambda 传给嵌套对象/另一执行点。
  2. 标注 crossinline 表明内联体在非直接上下文执行。
  3. 编译器禁止该 lambda 内非局部 return。
  4. 需要退出时使用标签 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,类型参数仍是普通擦除参数。

原理流程

  1. 声明 inline fun <reified T>。
  2. 调用点展开函数体。
  3. 实参类型写入展开代码。
  4. 函数内 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 开销与代码体积之间权衡。

概念解释

内联收益是减少函数对象与调用开销,成本是代码复制。短小工具函数收益明显;大函数、多调用点应评估产物体积,必要时保留普通函数。

原理流程

  1. 编译器按调用点展开函数体。
  2. 每个调用点独立复制指令。
  3. 调用点数量乘函数体体积得到增量。
  4. 热点小函数内联划算,大函数需实测对比。

代码或图示

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 接入外部约定对象;二者可组合但职责不同,不要把内联委托理解为自动委托。

原理流程

  1. 属性访问器加 inline 修饰。
  2. 访问器体在使用点展开。
  3. 委托属性声明 by 委托对象,读写转发到约定方法。
  4. 委托对象内部逻辑不受 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 场景也禁止非局部返回。

原理流程

  1. lambda 作为 inline 参数:体展开到外层函数内。
  2. 裸 return 退出外层函数。
  3. lambda 作为非 inline 参数:编译为函数对象,裸 return 报错。
  4. 局部退出用 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 兼容约束。

原理流程

  1. 编译器检查 inline 函数结构。
  2. 递归自调用:无法静态展开,按规则回退或报错。
  3. 受限参数标注组合校验通过。
  4. 不符合内联条件时编译器诊断提示。

代码或图示

// 递归函数不适合声明 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 属于演进中特性,不同版本可用性不同,不确定处标注待确认。

原理流程

  1. 函数声明行为约定(返回、参数、调用关系)。
  2. 编译器依据契约更新数据流结论。
  3. lambda 后变量被智能转换。
  4. 契约语法与支持范围按目标版本核对。

代码或图示

// 标准库契约示例思路:requireNotNull 调用后编译器知晓接收者非空
// 自定义 contract 写法与稳定性以官方文档及项目版本为准(待确认)

常见误区

  • 把内部实验契约语法写入公共库:版本升级可能变化。
  • 以为契约能运行时校验:契约是编译期数据流辅助。

追问

  • 答:契约与运行时断言关系?答:断言在运行时抛异常;契约只在编译期辅助推断,二者不互相替代。
  • 答:如何确认版本支持?答:查 kotlinlang.org contracts 章节并在工程编译验证。

04.8.1.3-043 contract 如何让智能转换穿透 lambda?

一句话结论

普通判空在 lambda 内部不影响外部变量类型;契约声明「lambda 返回后参数满足某条件」后,编译器可在 lambda 调用后对外部变量做智能转换。

概念解释

没有契约时,编译器不了解高阶函数对参数做了什么,lambda 结束后外部变量类型不收窄。契约把行为约定告诉编译器,使 smart cast 跨函数边界生效。

原理流程

  1. 高阶函数接收变量并在内部校验。
  2. 契约声明调用返回后参数非空/类型匹配。
  3. 编译器在调用点后收窄变量类型。
  4. 后续代码按收窄类型访问成员。

代码或图示

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:内层块拥有外部配置对象的上下文,可直接调用其方法。常见于构建器、配置声明、布局/路由定义。

原理流程

  1. 定义配置类与构建方法。
  2. 高阶函数接收带接收者 lambda。
  3. 嵌套块逐层配置子节点。
  4. 约定方法(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 为参数,嵌套块依次绑定子配置对象。

原理流程

  1. 构建函数声明 receiver.() -> Unit 参数。
  2. 创建接收者实例。
  3. 把实例作为 this 调用 lambda。
  4. 块内方法调用落到接收者对象上。

代码或图示

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 让同标记的外层接收者在内部块中不可见,必须显式限定。

原理流程

  1. 定义带 @DslMarker 元注解的注解。
  2. 标注到各 DSL 接收者类型上。
  3. 内层块解析成员时屏蔽同标记外层接收者。
  4. 确需访问外层需显式保存引用并限定调用。

代码或图示

@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 可屏蔽外层隐式访问;显式限定消除歧义,避免子节点误调用父节点方法。

原理流程

  1. 外层构建函数绑定父接收者。
  2. 内层块创建子对象并绑定子接收者。
  3. 成员查找先匹配子接收者。
  4. 父层访问通过保存的引用或限定 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 接收者是可变缓冲对象,块内调用追加方法,构建结束返回只读/不可变结果。与手写循环和缓冲拼接相比,结构更集中。

原理流程

  1. 构建函数创建内部可变缓冲。
  2. 以缓冲为接收者执行 lambda。
  3. 块内调用追加/put 方法。
  4. 返回转换后的不可变集合或字符串。

代码或图示

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 可让配置对象直接被调用,操作符重载提供 +、[] 一类语法。

原理流程

  1. 父接收者声明子节点工厂方法。
  2. 工厂方法创建子对象、加入容器、以子对象为接收者执行 lambda。
  3. 需要简洁调用时实现 invoke/操作符约定。
  4. 构建完成返回根配置对象。

代码或图示

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 指令。每种符号有固定约定名与参数/返回类型要求;语义应与内置类型直觉一致,避免可读性陷阱。

原理流程

  1. 类型声明 operator fun plus(other: T): T。
  2. 编译器把 a + b 解析为 a.plus(b)。
  3. 签名不符时操作符表达式编译报错。
  4. 运行时调用约定方法。

代码或图示

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、业务谓词。语法限制严格:参数固定一个,接收者明确;普通点号调用仍可使用。

原理流程

  1. 函数加 infix 修饰,声明单参数。
  2. 调用写 接收者 函数名 参数。
  3. 编译器解析为 接收者.函数名(参数)。
  4. 多参数或扩展约束不符时不可中缀调用。

代码或图示

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 自动生成。普通类手动实现组件方法;组件数量、类型与解构变量一一对应,多余组件可用 _ 跳过。

原理流程

  1. 声明 operator fun componentN(): T。
  2. 解构声明按编号调用组件方法。
  3. 变量类型按组件返回类型推断。
  4. 组件缺失或数量不符编译报错。

代码或图示

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 形式。

原理流程

  1. 类型声明 operator fun invoke(args): R。
  2. 调用 obj(args) 解析为 obj.invoke(args)。
  3. 函数体执行对象持有的行为。
  4. 重载按参数签名选择 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 循环遍历,无需继承特定集合类。

原理流程

  1. 声明 operator fun get(idx: T): R。
  2. obj[i] 编译为 obj.get(i)。
  3. set 约定支持 obj[i] = v。
  4. 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。类型实现比较方法后,可在排序、区间与条件判断中使用比较符号。

原理流程

  1. 声明 operator fun compareTo(other: T): Int。
  2. 编译器把比较符号解析为 compareTo 加结果判断。
  3. 返回值按小于/等于/大于约定。
  4. 排序工具按 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 是扩展函数排除上界。

原理流程

  1. a..b 解析为 a.rangeTo(b)。
  2. 区间对象实现迭代与包含协议。
  3. in 调用区间 contains 判断。
  4. 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 需通过工具类调用。

原理流程

  1. 扩展编译为静态函数,首参为接收者。
  2. 原类方法表不包含扩展。
  3. Java 按包装类静态方法签名查找。
  4. 直接在 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 调用与反射问题。

原理流程

  1. 顶层函数编译为包装类静态方法。
  2. 扩展函数首参为接收者参数。
  3. @JvmName 覆盖生成类名/方法名。
  4. 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 通配符签名。

原理流程

  1. Java List<? extends Animal>:生产者协变。
  2. Kotlin 侧呈现为 out Animal 投影。
  3. Java ? super Animal:消费者逆变。
  4. 不变类型两侧均为固定实参。

代码或图示

// 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 类签名时,通配符信息保留为投影类型。协变投影可读不可写,逆变投影可写(按下界类型)读取受限;无界通配符按星投影处理。

原理流程

  1. 解析 Java 方法/字段泛型签名。
  2. 通配符转换为 Kotlin 投影类型。
  3. 编译器按投影位置检查读写操作。
  4. 不兼容读写报错。

代码或图示

// 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 的键值型变按位置分别处理。理解标注有助于判断集合赋值兼容。

原理流程

  1. 只读集合只提供读取方法,E 在返回位置。
  2. 声明 out E,子类型实参可向上替换。
  3. 可变集合提供 add/set,E 出现在参数位置。
  4. 读写并存保持不变。

代码或图示

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?>? 同时表达两层缺失;访问时先判容器,再处理元素空值。

原理流程

  1. 外层可空:安全调用 ?. 访问集合方法。
  2. 内层可空:元素取值后判空或过滤。
  3. 类型参数上界决定 T 本身是否可空。
  4. 两层检查互不替代。

代码或图示

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 与实参两侧推断。

原理流程

  1. 声明 <T, R> 多类型参数。
  2. 参数/返回类型引用各形参。
  3. 函数类型 (T) -> R 绑定形参。
  4. 调用处推断实参或显式指定。

代码或图示

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 重复出现时,别名把类型结构隐藏。泛型实参仍由编译器检查,别名不弱化类型约束。

原理流程

  1. 识别重复出现的复杂泛型/函数类型。
  2. 定义带类型参数的别名。
  3. 签名与属性使用别名。
  4. 编译期展开为原类型。

代码或图示

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。

原理流程

  1. 列出接口方法中 T 出现的位置。
  2. 仅返回位置:声明 out。
  3. 仅参数位置:声明 in。
  4. 两处都有:不变,或拆分只读/可变接口。

代码或图示

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 名称与版本支持需实测确认。

原理流程

  1. 定义 inline fun <reified T> parse(json: String): T?。
  2. 函数内调用序列化库按 T 解码。
  3. 调用处省略类对象参数。
  4. 库不支持时改为接收 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 场景:如何用扩展函数收敛工具方法组织?

一句话结论

按类型领域聚合扩展函数到工具文件,接收者类型明确、职责单一;业务代码链式调用,避免在各业务类内复制重复工具逻辑。

概念解释

扩展把「对某类型的操作」挂到类型上,调用者按接收者发现方法。组织时按接收者类型与领域分组,控制可见性,避免扩展泛滥与同名冲突。

原理流程

  1. 识别重复出现的类型操作。
  2. 按接收者类型建立工具文件。
  3. 实现扩展函数并补充文档/测试。
  4. 业务处导入后链式复用。

代码或图示

// 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 更贴近声明式结构。步骤:配置数据类、构建函数、子节点工厂、接收者上下文、最终校验与不可变返回。

原理流程

  1. 声明配置数据类与默认值。
  2. 根构建函数创建根实例并 apply lambda。
  3. 子方法创建子对象、加入容器、绑定子接收者。
  4. 校验配置后返回只读实例。

代码或图示

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 类型。

原理流程

  1. 声明 @DslMarker 元注解标注的自定义注解。
  2. 各 DSL 接收者类/接口标注该注解。
  3. 内层解析成员时屏蔽外层同标记接收者。
  4. 显式引用保存后可访问父层成员。

代码或图示

@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 是否捕获变量、调用频率与函数体大小;应以实测分配与耗时为准。

原理流程

  1. 普通高阶函数:lambda 包装为函数对象实例。
  2. 内联后:lambda 体并入调用点,无对象分配。
  3. 热点路径减少堆分配与 GC 压力。
  4. 大函数多调用点时代码体积增长抵消部分收益。

代码或图示

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 已有类对象,无内联期额外分配;成本主要在编译期展开。

原理流程

  1. 调用点展开时写入具体类型。
  2. 函数内 T::class 解析为该类型类对象引用。
  3. 类对象由 JVM 类加载提供,不为 reified 新建。
  4. 反射调用按既有类对象执行。

代码或图示

inline fun <reified T> typeName(): String = T::class.java.name

常见误区

  • 以为 reified 在运行时生成类型标记对象:它是编译期保留。
  • 在展开点之外长期持有 reified 类型引用:不可用。

追问

  • 答:reified 与显式传 KClass 性能差别?答:后者每次传类对象引用;reified 编译期确定,运行时无参数对象传递。
  • 答:类型擦除容器元素类型能靠 reified 恢复吗?答:不能,外层类型可判,元素实参仍擦除。

04.8.1.3-072 性能:扩展函数是否增加虚分发成本?

一句话结论

扩展编译为静态函数调用,不进入虚方法表,没有多态分派开销;调用直接绑定静态解析的实现,性能上接近普通静态方法调用。

概念解释

与成员虚方法按实际类型分派不同,扩展在编译期确定目标函数。运行时调用是静态转发,不产生虚查找;但扩展不能被子类覆写,这是静态解析的代价。

原理流程

  1. 编译期解析接收者类型对应扩展函数。
  2. 生成静态调用指令,接收者作为首参。
  3. 运行时不做虚方法表查找。
  4. 调用成本接近直接静态调用。

代码或图示

fun String.shout(): String = this.uppercase()
"hello".shout() // 静态解析,非虚分派

常见误区

  • 把扩展当成员方法期待重写:分发模型不同。
  • 高频扩展调用叠加多层链式:方法调用次数仍需计入成本。

追问

  • 答:扩展与顶层普通函数性能差异?答:基本一致,都是静态调用,接收者作为参数传入。
  • 答:成员虚方法何时使用?答:需要运行时多态分派时使用类层级开放成员。

04.8.1.3-073 坑:扩展静态解析导致的多态误判有哪些表现?

一句话结论

变量声明为父类型时,同名扩展按父类型解析,即使实际是子类实例;期待按实际类型走子类扩展会得到错误结果,这是静态解析而非虚分派。

概念解释

误判常出现在多类型层级与策略分发场景。修复方式是把行为改为接口/开放成员,或用 sealed + when 按实际类型分派。

原理流程

  1. 定义父类、子类与各自同名扩展。
  2. 父类型变量持有子类实例。
  3. 编译期按父类型选择扩展。
  4. 运行时不切换到子类扩展。

代码或图示

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 体内给出诊断。

原理流程

  1. 检查参数修饰组合是否合法。
  2. noinline 参数不能参与内联展开上下文。
  3. crossinline 内禁止非局部返回。
  4. 冲突组合在编译期报错。

代码或图示

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 引用时,状态变化在各段间可见。

原理流程

  1. 编译器识别被 lambda 捕获的局部变量。
  2. 内联展开后变量留在调用点作用域。
  3. lambda 体对变量的读写成为局部变量读写。
  4. 多段 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 设计时应明确每层允许的接收者成员,并用标记收窄作用域。

原理流程

  1. 内层块解析成员,沿接收者链查找。
  2. 未加 DslMarker 时外层成员隐式可见。
  3. 误调父方法改变父配置。
  4. 编译通过但运行结构不符合预期。

代码或图示

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 过滤,或在边界处把投影收窄为确定类型。

原理流程

  1. 投影类型按上界暴露读取能力。
  2. 需要具体类型时检查类型令牌。
  3. reified 函数在编译期保留目标类型。
  4. 强转前确认类型兼容,避免运行时 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 操作。

原理流程

  1. inline 函数展开处确定 T。
  2. 匿名类实例在展开代码内创建。
  3. 匿名类内部不能把 T 作为泛型实参保留。
  4. 长期保存需显式传入类型令牌对象。

代码或图示

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 扩展在不改原类的前提下补充工具方法。两者复用机制不同:成员属于类型,扩展属于外部工具层。

原理流程

  1. Java 默认方法进入接口实现表,子类可覆盖。
  2. Java 静态方法通过接口名调用。
  3. Kotlin 扩展编译为静态工具函数。
  4. 扩展不参与虚分派,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 每个签名临时放宽。互操作时两侧投影类型相互映射。

原理流程

  1. Kotlin 接口声明 Producer<out T>。
  2. 所有使用点按协变规则判断兼容。
  3. Java 方法签名写 List<? extends T>。
  4. 互操作映射为对应投影类型。

代码或图示

// 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 是编译期消除手段。两者都支持简洁回调语法,对象生命周期与分发机制不同。

原理流程

  1. Java lambda:函数式接口实例由运行时机制生成。
  2. Kotlin 普通高阶函数:函数类型对象传入。
  3. Kotlin inline:体展开到调用点,无函数对象。
  4. 互操作时 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 状态、编译器诊断变化以官方文档与实测为准。

原理流程

  1. 记录编译器与标准库版本。
  2. 查官方文档特性稳定状态。
  3. 最小工程编译验证语法、诊断与投影行为。
  4. 不确定点标注「待确认」与验证步骤。

代码或图示

// 待确认:目标版本对 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,以及擦除后容器元素类型不可恢复。

原理流程

  1. 写 inline 函数与 reified 类型参数。
  2. 函数内访问 T::class/is T。
  3. 调用处推断或显式指定实参。
  4. 说明运行时类对象来自编译期展开。

代码或图示

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 侧不可见。

原理流程

  1. 确定接收者类型与操作职责。
  2. 声明扩展函数,体内访问 this。
  3. 调用处 receiver.method(args)。
  4. 说明编译为静态工具函数。

代码或图示

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,读写并存保持不变;发现协变接口写入方法或逆变接口返回值即判错并修正。

概念解释

评分点:型变方向判断、位置检查、编译约束理解。给出错误标注案例与修正后接口,说明外部赋值兼容关系。

原理流程

  1. 列出每个方法的参数与返回类型。
  2. 判断 T 是生产者还是消费者。
  3. 错误标注违反位置约束时编译报错。
  4. 修正为对应型变或拆分接口。

代码或图示

// 错误: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 防止跨层误访问。

原理流程

  1. 声明配置数据类。
  2. 根构建函数 block: Root.() -> Unit。
  3. 子工厂方法创建子对象、加入列表、apply 内层 lambda。
  4. 返回根配置实例。

代码或图示

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,其余默认内联。

原理流程

  1. 定位报错在参数声明还是 lambda 体内。
  2. 检查修饰组合是否合法。
  3. crossinline 体内裸 return 改为标签返回。
  4. 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、比较运算符与排序工具;需要同时满足其他接口时按多界约束补充。

概念解释

上界把类型参数限制在可比较类型范围内,编译器允许调用上界接口方法。常见于最值、排序、区间判断工具函数。

原理流程

  1. 类型参数声明上界 Comparable<T>。
  2. 实参必须实现该接口。
  3. 函数体内按上界类型调用成员。
  4. 调用方传入满足约束的类型。

代码或图示

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 实现、无字段约束。派生属性不保存状态,依赖接收者公开可见状态;可变扩展属性需在接收者状态上落地修改。

原理流程

  1. 声明 val Receiver.prop: Type。
  2. getter 内读取 this 状态计算。
  3. 访问属性触发 getter。
  4. 不存储独立字段。

代码或图示

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 一类标准库函数获得穿透转换。自定义契约语法与稳定范围按版本确认,不确定处用显式判空兜底。

原理流程

  1. 高阶/校验函数接收变量并内部检查。
  2. 契约把检查结论告知编译器。
  3. 调用点后变量类型收窄。
  4. 后续代码按收窄类型访问成员。

代码或图示

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 等对应约定,保持操作符含义清晰。

原理流程

  1. 类型声明 plus 约定方法。
  2. 方法内组合两个实例字段。
  3. 返回新实例,不修改原对象。
  4. 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;仅在语义自然、可读性提升时使用,参数固定一个,普通点号调用仍可用。

概念解释

中缀适合关系型领域表达:归属、匹配、组合。设计时确认方法名读起来像领域谓词;业务逻辑复杂或多参数时退回普通方法。

原理流程

  1. 声明 infix fun Receiver.method(other: T): R。
  2. 调用 receiver method other。
  3. 编译器解析为方法调用。
  4. 语义不清时用点号形式。

代码或图示

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,因此不变,不能这样赋值。

原理流程

  1. List<out E> 声明元素只在返回位置出现。
  2. String <: Any,子类型实参可替换。
  3. 赋值后读取元素为 Any 类型。
  4. 尝试写入会被编译器拒绝。

代码或图示

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 协变,函数类型子类型关系按此推导。

概念解释

能接受更宽参数的函数可替代窄参数函数(逆变),返回更具体类型的函数可替代宽返回函数(协变)。标准库函数类型已按此型变规则定义。

原理流程

  1. 函数类型参数位置:消费者,逆变。
  2. 返回位置:生产者,协变。
  3. 子类型替换按两个方向分别检查。
  4. 高阶函数参数按函数类型型变兼容判断。

代码或图示

// (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 无法表达泛型实参。

原理流程

  1. 序列化时保存目标类型信息(令牌/泛型描述)。
  2. 反序列化按保存类型重建对象。
  3. 缓存键不含泛型实参,必要时把类型令牌纳入键。
  4. 运行时 is 只能判断外层类型。

代码或图示

// 序列化库通常要求显式泛型类型标记;reified 扩展在编译期携带外层类型
inline fun <reified T> decode(raw: String): T? = /* 库类型化 API */ null

常见误区

  • 依赖容器运行时恢复元素泛型:擦除不可得。
  • 缓存不同泛型实参共用键而不区分类型:取值强转出错。

追问

  • 答:嵌套泛型如何携带类型?答:库支持的泛型序列化器/类型令牌,普通 Class 不够。
  • 答:反序列化失败如何排查?答:核对类型令牌、库版本与字段可空性,补充类型化测试。

04.8.1.3-096 扩展在模块分层中应使用在什么边界?

一句话结论

扩展适合补充同类型工具操作,按模块内可见性组织;跨模块公开扩展需评估 API 稳定性,避免在核心领域类型上堆叠外部扩展造成调用困惑。

概念解释

模块分层中,扩展可放在工具层补充领域类型操作;领域核心行为应留在类/接口内。扩展可见性按 private/internal/public 控制,跨模块公开属于 API 承诺。

原理流程

  1. 判断操作属于类型核心行为还是外部工具。
  2. 核心行为写成员/接口方法。
  3. 工具操作按接收者类型聚合扩展文件。
  4. 跨模块公开扩展纳入 API 兼容审查。

代码或图示

// 模块内工具扩展
internal fun Order.receiptText(): String = /* ... */

常见误区

  • 在领域核心类上挂大量跨模块扩展:调用方发现路径分散。
  • 内部辅助扩展误标 public:API 面扩大。

追问

  • 答:扩展与领域服务如何分工?答:无依赖的纯类型操作用扩展;有跨实体依赖与副作用的逻辑放服务类。
  • 答:公开扩展兼容注意什么?答:接收者类型演进会影响扩展签名,修改需评估 ABI。

04.8.1.3-097 DSL 安全性:编译期约束与运行期校验如何分工?

一句话结论

类型与结构合法性由编译期保证(方法存在、接收者类型、DslMarker 作用域);业务规则(必填项、取值范围、交叉约束)必须在运行期校验。

概念解释

DSL 语法正确不等于业务配置合法。编译期拦截结构错误,运行期校验语义约束;构建完成返回前统一检查,非法配置尽早失败。

原理流程

  1. 编译期:类型检查、接收者解析、标记作用域。
  2. 构建期:收集节点与参数。
  3. 运行期:校验必填、范围、关联一致性。
  4. 校验失败抛配置异常,不返回半成品对象。

代码或图示

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。

原理流程

  1. 调用方编译时复制 inline 函数体。
  2. 库后续修改内联实现。
  3. 已编译调用方仍保留旧展开代码。
  4. 行为不一致,二进制兼容风险产生。

代码或图示

// 公共库中:修改 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 逆变;赋值兼容沿子类型方向,收窄需类型检查或断言。

概念解释

规则分三层:基础类型层级、泛型型变、函数型变。编译器在赋值、传参、返回位置检查兼容;擦除后运行时只保留外层类型。

原理流程

  1. 基础类型按 Any?/Any/具体类型/Nothing 层级判断。
  2. 泛型实参按 out/in/不变规则判断兼容。
  3. 函数类型参数逆变、返回协变。
  4. 不兼容时编译报错,收窄需显式检查。

代码或图示

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 组织可读结构。理解组合方式才能在工程中选型而不是堆叠语法。

原理流程

  1. 用泛型抽象复用逻辑并标注型变。
  2. 用扩展为类型补充工具操作。
  3. 高频高阶函数 inline,需要类型判断时 reified。
  4. 配置/层级结构用 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 2.x 版本上核对 contracts 自定义语法的稳定状态与诊断行为
  • [ ] 核对 Java 通配符与 Kotlin 投影互操作导出签名的实测结果
  • [ ] 补充 reified 序列化辅助与目标序列化库版本兼容性记录
  • [ ] 整理 inline 公共 API 的 ABI 兼容审查清单与示例