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

04.8.1.2 面向对象与 data、sealed、value class

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.8 Kotlin / 04.8.1 语言核心与类型系统

本节要解决的问题

本节覆盖 Kotlin 面向对象设施:构造器与初始化顺序、属性与幕后字段、委托属性、伴生对象与单例、嵌套类与 inner 类、继承与重写,以及 data class、sealed 层级、value class、枚举的建模契约与字节码表现。版本基线为 Kotlin 2.x、JDK 17+;版本行为不确定处标注「待确认」并给出验证点。

04.8.1.2-001 Kotlin 类声明的默认成员与默认修饰符是什么?

一句话结论

Kotlin 类默认 public、final(不可继承),成员默认 public;要被继承或重写必须显式加 open,抽象成员本身可被重写。

概念解释

与 Java 类默认可被继承不同,Kotlin 倾向于类封闭:非 open 类不能派生子类,非 open 成员不能被重写。可见性默认 public,需要收窄时显式写 private/internal/protected。

原理流程

  1. 编译器为类与成员应用默认可见性 public。
  2. 类默认 final,禁止被继承。
  3. 成员默认 final,禁止子类重写。
  4. 需要扩展点时在类或成员前加 open,抽象类与接口成员除外。

代码或图示

class Greeter {              // public final
    fun hello() = "hi"       // public final
}

open class Base {            // 可被继承
    open fun render() = ""  // 可被重写
}

常见误区

  • 以为 Kotlin 类默认像 Java 一样可继承:默认 final。
  • 子类重写未加 open 的成员:编译报错。

追问

  • 答:抽象类成员默认可重写吗?答:抽象成员没有实现,子类必须实现;普通成员仍需 open 才能重写。
  • 答:open 与 abstract 区别?答:open 提供默认实现且允许重写;abstract 无实现,子类必须覆盖。

04.8.1.2-002 主构造器语法与参数默认值如何使用?

一句话结论

主构造器写在类名后,参数可带默认值;默认值让调用方省略对应实参,编译器按顺序生成重载或默认参数调用形态。

概念解释

主构造器是类的主要初始化入口,参数可直接声明为属性。默认值减少重载构造器数量,调用时按命名参数跳过有默认值的参数。与 Java 互操作时默认参数需要 @JvmOverloads 才生成多个重载。

原理流程

  1. 类名后括号内声明构造参数与默认值。
  2. 调用方按位置或命名传参,缺省参数取默认值。
  3. 主构造参数可加 val/var 直接成为属性。
  4. 初始化逻辑放入 init 块或属性初始化器。

代码或图示

class User(val name: String, val age: Int = 0, val active: Boolean = true)

val a = User("Ann")
val b = User("Bob", age = 30)

常见误区

  • 以为 Java 调用 Kotlin 构造器自动看到默认参数重载:需要 @JvmOverloads。
  • 默认值引用可变共享对象:多个实例可能共享同一可变集合。

追问

  • 答:构造参数默认值何时求值?答:每次构造缺省该参数时按表达式求值,具体共享语义需结合表达式判断。
  • 答:命名参数有什么限制?答:调用时按名称传参,顺序可调整,具体规则以编译器诊断为准。

04.8.1.2-003 次构造器与主构造器的委托关系是什么?

一句话结论

次构造器用 constructor 声明,必须直接或间接委托主构造器(this(...));委托完成后再执行次构造器自身逻辑。

概念解释

主构造器是初始化核心,次构造器提供备选构造入口。次构造器不能绕过主构造器初始化流程;当类没有主构造器时,次构造器互相委托。

原理流程

  1. 声明 constructor(参数) : this(主构造参数)。
  2. 先执行主构造器参数初始化与 init 块。
  3. 再执行次构造器体内语句。
  4. 多层委托最终汇聚到主构造器。

代码或图示

class Person(val name: String, val age: Int) {
    constructor(name: String) : this(name, 0)
}

常见误区

  • 次构造器忘记委托主构造器:编译报错。
  • 在次构造器里重复初始化主构造属性:职责重叠。

追问

  • 答:没有主构造器的类如何写次构造器?答:类声明不带主构造括号,各次构造器用 this(...) 互相委托。
  • 答:次构造器能声明属性吗?答:属性应在主构造器或类体声明,次构造器主要承担参数转换与委托。

04.8.1.2-004 init 块的执行顺序与作用是什么?

一句话结论

init 块是主构造器的初始化逻辑段,按类体内出现顺序与属性初始化器交错执行;父类初始化先于子类 init。

概念解释

属性初始化器与 init 块在构造期按书写顺序依次运行。init 可读取已初始化属性、做参数校验;多个 init 块按顺序拼接为初始化流程。

原理流程

  1. 父类主构造参数与初始化先执行。
  2. 子类属性初始化器按顺序运行。
  3. 遇到 init 块执行其中语句。
  4. 全部初始化完成后对象才可使用。

代码或图示

class Range(val start: Int, val end: Int) {
    init {
        require(start <= end) { "start must <= end" }
    }
    val size = end - start
}

常见误区

  • 在 init 中引用尚未初始化的属性:读到默认值或触发未初始化异常。
  • 把业务懒加载逻辑写进 init:构造期成本与副作用叠加。

追问

  • 答:属性初始化器与 init 谁先执行?答:按类体内书写顺序交错执行,不是所有属性先于所有 init。
  • 答:init 中抛异常会怎样?答:构造失败,对象不返回,异常沿构造调用栈传播。

04.8.1.2-005 主构造器参数如何直接成为属性?

一句话结论

在主构造参数前加 val(只读)或 var(可变),编译器自动生成对应属性、幕后字段与访问器;不加关键字的参数仅为构造期局部参数。

概念解释

这是 Kotlin 替代 Java 「字段 + 构造器赋值 + getter/setter」样板的核心语法。加 val/var 的参数在类体内可作为属性访问;纯参数只在初始化阶段可用。

原理流程

  1. 构造参数带 val/var:编译器生成属性声明。
  2. 生成幕后字段与默认访问器。
  3. 初始化期把构造值写入字段。
  4. 类体内与外部按属性规则访问。

代码或图示

class Book(val title: String, var pages: Int, author: String) {
    val authorLabel = author.uppercase()
}

常见误区

  • 忘记加 val/var 却在方法内访问该参数:编译报错。
  • 把应作为状态的参数写成纯参数:后续无法读取。

追问

  • 答:构造属性可以自定义访问器吗?答:可以,在类体中为同名属性补 getter/setter 逻辑,幕后字段规则随之变化。
  • 答:val 构造属性能否在 init 后修改?答:不能重新赋值,需要可变状态用 var。

04.8.1.2-006 属性声明与自定义 getter/setter 如何工作?

一句话结论

属性由声明类型、可选幕后字段与访问器组成;val 只有 getter,var 有 getter/setter,可自定义访问逻辑而不改变外部调用方式。

概念解释

外部通过属性名访问,内部可在 getter/setter 中做校验、派生计算或惰性取值。默认实现读写幕后字段;自定义访问器决定字段是否存在。

原理流程

  1. 声明 val/var 属性与类型。
  2. 默认生成幕后字段与访问器。
  3. 自定义 getter:每次访问计算返回值。
  4. 自定义 setter:写入前校验或转换,可决定是否落字段。

代码或图示

class Rectangle(var width: Double, var height: Double) {
    val area: Double get() = width * height
    var normalized: Double
        get() = width
        set(value) { width = value.coerceAtLeast(0.0) }
}

常见误区

  • 自定义 getter 里递归调用属性自身:造成无限递归,应通过幕后字段或局部值访问。
  • setter 中不写回字段:外部观察不到值变化。

追问

  • 答:派生属性需要幕后字段吗?答:纯计算派生属性可不存储字段,每次 getter 现算。
  • 答:var 属性只读化的子类重写规则见哪题?答:见本节 open 属性与重写相关题目。

04.8.1.2-007 幕后字段 field 的作用与限制是什么?

一句话结论

field 是访问器中引用属性幕后字段的隐式标识符,只在需要存储值的访问器内可用;它不能被显式声明,也不能在属性外访问。

概念解释

编译器在属性需要存储状态时生成幕后字段。自定义 setter 中用 field 读取当前值并写入新值;纯计算属性没有字段,field 不可用。

原理流程

  1. 属性默认声明触发幕后字段生成。
  2. setter 内 field 指向该字段,可读可写。
  3. 纯派生 getter 不产生字段,访问器内无 field。
  4. 字段对外部不可见,只能通过访问器间接读写。

代码或图示

var name: String = ""
    set(value) {
        field = value.trim()
    }

常见误区

  • 在 getter 中写 field 却未存储状态:派生属性无字段,编译报错。
  • 手动声明一个同名私有字段再用 field:重复存储,语义混乱。

追问

  • 答:何时编译器不生成幕后字段?答:访问器完全派生、不读写存储值时;具体以编译器实现为准。
  • 答:field 能在 lambda 外的普通方法中使用吗?答:不能,field 仅在属性访问器作用域内可见。

04.8.1.2-008 幕后属性(backing property)约定如何使用?

一句话结论

当需要对外暴露只读视图、对内保留可变状态时,用私有可变字段配合公开只读属性,称为幕后属性约定;避免直接暴露 MutableList 给外部修改。

概念解释

幕后属性是「私有存储 + 公开访问」的封装手法:内部 private val/var 保存可变状态,外部属性返回只读视图或派生值。与幕后字段不同,它是开发者显式写的一对属性。

原理流程

  1. 声明私有可变存储属性。
  2. 公开属性只读暴露状态或只读集合视图。
  3. 内部方法修改私有存储。
  4. 外部无法绕过公开访问器改写内部状态。

代码或图示

class Team {
    private val _members = mutableListOf<String>()
    val members: List<String> get() = _members

    fun add(name: String) { _members.add(name) }
}

常见误区

  • 公开属性直接返回内部可变集合引用:外部可绕过方法修改状态。
  • 用命名约定 _members 却没有公开只读视图:封装不完整。

追问

  • 答:返回只读视图与复制集合如何选择?答:视图避免拷贝成本,确认内部不会被外部长期持有时使用;需要隔离快照时复制。
  • 答:幕后属性与委托属性关系?答:二者解决不同问题,委托属性把读写逻辑交给委托对象,幕后属性解决可见性封装。

04.8.1.2-009 lateinit 属性在类成员上有哪些位置限制?

一句话结论

lateinit 只能修饰类的非空 var 属性,不能是局部变量、不能有自定义 getter/setter、不能用于基本类型,也不能直接带初始值。

概念解释

lateinit 解决构造期拿不到值、之后由框架或生命周期回调注入的非空属性。基本类型有默认零值,不适用延后初始化;局部变量作用域短,可直接判空或委托。

原理流程

  1. 属性声明为 lateinit var,类型非空。
  2. 不提供构造初始值。
  3. 使用前由外部赋值。
  4. 访问时检查初始化状态,未赋值抛专用异常。

代码或图示

class Service {
    @Inject lateinit var repo: UserRepository
    fun initialized() = ::repo.isInitialized
}

常见误区

  • 给 Int、Boolean 加 lateinit:基本类型不支持。
  • 在 lateinit 属性上写自定义 getter/setter:限制冲突。

追问

  • 答:lateinit 与可空 var x: T? = null 如何选型?答:终值非空、生命周期外部注入用 lateinit;值可能合法缺失用可空类型。
  • 答:未初始化访问抛什么异常?答:UninitializedPropertyAccessException。

04.8.1.2-010 委托属性 by 的执行模型是什么?

一句话结论

属性读写被委托给一个提供 getValue/setValue 约定的对象;每次访问属性都转发到委托对象,委托内部决定存储、计算与通知逻辑。

概念解释

by 把属性访问逻辑抽出到委托类。标准库提供 lazy、observable、notNull 等常用委托;自定义委托实现约定运算符即可复用。

原理流程

  1. 声明 val/var x by delegate。
  2. 读取属性:编译器调用委托的 getValue(thisRef, property)。
  3. 写入 var 属性:调用 setValue(thisRef, property, value)。
  4. 委托对象持有状态、缓存或变更通知逻辑。

代码或图示

val cached: String by lazy { expensiveLoad() }
var nickname: String by Delegates.observable("") { _, old, new ->
    println("$old -> $new")
}

常见误区

  • 以为委托属性在构造期就执行计算:lazy 等委托按访问时机触发。
  • 委托对象被多个属性共享:注意状态是否需要按属性隔离。

追问

  • 答:委托属性与类委托 by 区别?答:委托属性代理单个属性读写;类委托代理整个接口实现,见后续题目。
  • 答:委托约定方法需要什么修饰?答:使用 operator 修饰 getValue/setValue,详见泛型与约定章节。

04.8.1.2-011 标准库常用委托 lazy、observable、notNull 分别解决什么问题?

一句话结论

lazy 按需计算并缓存只读值;observable 在写入时回调旧值与新值;notNull 提供延后赋值的可空兜底,首次读取前必须赋值。

概念解释

三者覆盖常见属性模式:惰性初始化、属性变更观察、非空延后赋值。委托把样板逻辑标准化,业务属性只声明委托与初始策略。

原理流程

  1. lazy:首次访问执行 lambda,结果缓存,后续复用。
  2. observable:每次 setter 调用先更新值,再触发回调。
  3. notNull:内部状态初始为空,赋值后读取;未赋值读取抛异常。
  4. 委托按属性类型适配只读或可变属性。

代码或图示

val config by lazy { loadConfig() }
var theme by Delegates.observable("light") { _, _, n -> applyTheme(n) }
lateinit var token: String  // 或 Delegates.notNull<String>()

常见误区

  • 把 observable 用于只读 val:它服务可变属性写入观察。
  • 期待 lazy 值可刷新:缓存结果不变,需要刷新应重建对象或换委托。

追问

  • 答:lazy 线程安全模式由什么控制?答:LazyThreadSafetyMode 参数,默认模式以标准库版本为准。
  • 答:notNull 与 lateinit 差别?答:notNull 是委托,可用于局部或属性;lateinit 是属性修饰符,限制见前题。

04.8.1.2-012 如何自定义委托属性的 getValue/setValue 约定?

一句话结论

定义委托类,用 operator 实现 getValue(只读/可变都需要)与 setValue(仅可变属性需要),接收引用对象与属性描述符参数。

概念解释

约定方法签名包含 thisRef(所属类实例)与 KProperty(属性元信息)。委托可据此区分不同属性、读取元数据或实现通用缓存逻辑。

原理流程

  1. 声明委托类,持有内部状态。
  2. 实现 operator fun getValue(thisRef: Any?, property: KProperty<*>): T。
  3. 可变委托补 operator fun setValue(...)。
  4. 属性声明 by 委托实例,编译器自动转发读写。

代码或图示

class TrimDelegate : ReadWriteProperty<Any?, String> {
    private var value = ""
    override fun getValue(thisRef: Any?, property: KProperty<*>) = value
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        this.value = value.trim()
    }
}

var label: String by TrimDelegate()

常见误区

  • 漏掉 operator 修饰:约定不生效,属性无法委托。
  • 可变属性委托只写 getValue:写入编译报错。

追问

  • 答:ReadWriteProperty 接口提供什么?答:标准库约定接口,减少手写重复签名;只读场景用 ReadOnlyProperty。
  • 答:委托能否访问属性注解或名称?答:通过 KProperty 参数读取名称、注解等元信息。

04.8.1.2-013 伴生对象 companion object 在类中扮演什么角色?

一句话结论

伴生对象是类内部的单例对象,承载类级别的工厂方法、静态常量与静态逻辑;它绑定类名,调用方可通过类名直接访问其成员。

概念解释

Kotlin 没有 static 关键字,类级逻辑放在伴生对象中。伴生对象可实现接口、定义属性与方法,每个类最多一个伴生对象。

原理流程

  1. 类体内声明 companion object { ... }。
  2. 编译器为其生成绑定类的单例实例。
  3. 外部通过 类名.成员 访问伴生对象方法与属性。
  4. 伴生对象在类加载/首次访问时初始化。

代码或图示

class User private constructor(val name: String) {
    companion object {
        fun create(name: String): User = User(name.trim())
        const val MAX_LEN = 64
    }
}

val u = User.create("Ann")

常见误区

  • 把实例状态放进伴生对象:类级单例状态被所有实例共享。
  • 以为伴生对象成员在 JVM 上天然是静态方法:需要 @JvmStatic 才生成静态签名。

追问

  • 答:伴生对象可以命名吗?答:可以显式命名,默认名称为 Companion。
  • 答:伴生对象能否继承类或实现接口?答:可以,对象声明支持继承与接口实现。

04.8.1.2-014 @JvmStatic 在伴生对象互操作中的必要性是什么?

一句话结论

伴生对象方法默认是对象实例方法,Java 侧需通过 Companion 对象调用;加 @JvmStatic 后编译器额外生成静态方法签名,Java 可按类名直接调用。

概念解释

Kotlin 源码层用类名访问伴生成员,但字节码形态默认是伴生对象实例方法。@JvmStatic 在方法或属性上生成 JVM 静态成员,兼容 Java 静态调用习惯。

原理流程

  1. 伴生对象方法编译为对象实例方法。
  2. 标注 @JvmStatic 后,编译器同时生成静态转发方法。
  3. Java 侧既可走静态签名,也可访问伴生对象实例。
  4. 属性标注后生成静态 getter/setter 或字段形态。

代码或图示

companion object {
    @JvmStatic
    fun factory(): User = User("x")
}

常见误区

  • 不加注解就期待 Java 写 User.factory():实际需 User.Companion.factory()。
  • 对伴生对象属性滥用 @JvmStatic:按需生成,避免签名膨胀。

追问

  • 答:@JvmStatic 能标注在普通类成员上吗?答:主要用于伴生对象与顶层对象场景,普通实例成员不适用静态语义。
  • 答:静态方法与实例方法会重复生成吗?答:按注解生成额外静态转发,原有对象方法形态保留。

04.8.1.2-015 伴生对象方法与属性在 JVM 字节码上是什么形态?

一句话结论

伴生对象编译为类内部的单例实例,成员默认是该实例的方法与字段;加 @JvmStatic/@JvmField 后才对应生成静态方法或静态字段。

概念解释

理解字节码形态有助于排查 Java 调用、反射与序列化问题。伴生对象本身是一个对象实例,其状态在类级别共享;静态注解决定对外签名是静态还是实例访问。

原理流程

  1. 编译器为类生成伴生对象实例字段。
  2. 伴生方法编译为实例方法,属性为实例字段/访问器。
  3. @JvmStatic 生成静态转发方法。
  4. @JvmField 暴露静态字段而非访问器。

代码或图示

class Session {
    companion object {
        var counter: Int = 0
        @JvmStatic fun reset() { counter = 0 }
    }
}

常见误区

  • 按源码 类名.方法 推断字节码一定是静态方法:默认是伴生实例方法。
  • 反射时找不到静态方法:先确认是否标注了 @JvmStatic。

追问

  • 答:伴生对象属性在 Java 侧如何访问?答:通过伴生对象实例的 getter/setter,或 @JvmField 暴露字段。
  • 答:伴生对象初始化时机?答:类加载或首次访问伴生对象时,具体以 JVM 类加载规则为准。

04.8.1.2-016 object 单例声明如何保证线程安全初始化?

一句话结论

object 声明编译为饿汉式单例,实例在类加载阶段由 JVM 机制初始化,多线程下只需一次实例化;初始化逻辑写在对象体或 init 块中。

概念解释

对象声明没有公开构造器,外部通过对象名访问。JVM 类加载机制保证静态初始化的线程安全,不需要手写双重检查锁。对象内部状态的并发读写仍需自行保护。

原理流程

  1. 编译器为 object 生成单例类与持有实例的静态字段。
  2. 类加载时执行对象体初始化,构造唯一实例。
  3. 外部引用同一实例。
  4. 可变状态在多线程访问时需要同步或并发容器。

代码或图示

object AppRegistry {
    private val services = mutableMapOf<String, Any>()
    fun register(name: String, service: Any) { services[name] = service }
}

常见误区

  • 以为 object 内部可变状态天然线程安全:初始化安全不代表状态读写安全。
  • 在单例中持有短生命周期资源:生命周期错配导致泄漏。

追问

  • 答:饿汉单例与懒汉单例如何取舍?答:对象声明是饿汉;需要按需初始化用 lazy 委托或伴生工厂。
  • 答:单例能否实现接口?答:可以,对象声明可继承类与实现接口。

04.8.1.2-017 object 表达式(匿名对象)与对象声明有什么区别?

一句话结论

object 表达式是就地创建的匿名对象,类似 Java 匿名内部类,可捕获外层变量;对象声明是具名单例,全局唯一实例,不产生每次新建的对象。

概念解释

对象表达式用 object : 类型 { ... } 创建一次性实例,常用于回调、临时策略;对象声明用 object 名称 { ... } 定义模块级单例。两者编译产物与生命周期不同。

原理流程

  1. 对象表达式在执行到该处时创建新实例。
  2. 可继承类/实现接口,覆盖成员。
  3. 捕获的外层变量按闭包规则持有。
  4. 对象声明在类加载时创建唯一实例,全局复用。

代码或图示

val listener = object : ClickListener {
    override fun onClick() { println("clicked") }
}

object GlobalRegistry { /* 单例 */ }

常见误区

  • 把匿名对象当单例复用:每次执行表达式都可能创建新实例。
  • 匿名对象持有外层长生命周期引用:引发内存泄漏。

追问

  • 答:对象表达式能省略父类型吗?答:可以,此时类型为匿名对象类型,成员仅在局部可见。
  • 答:SAM 接口场景优先用 lambda 还是对象表达式?答:函数式接口优先 lambda;需要多方法或附加状态时用对象表达式。

04.8.1.2-018 对象声明实现接口或继承类有哪些边界?

一句话结论

object 可以继承类、实现接口,并覆盖其抽象成员;单例实例同时扮演该类型角色,但不能再被实例化出第二个对象。

概念解释

对象声明是类与对象的结合体:有唯一实例,也有类型层级。工厂策略、常量实现、回调单例常通过对象实现接口暴露。

原理流程

  1. object Name : SuperClass, Interface { ... } 声明继承关系。
  2. 覆盖抽象成员与开放成员。
  3. 实例按对象声明规则唯一创建。
  4. 可作为父类型参数传递。

代码或图示

object ConsoleLogger : Logger {
    override fun log(msg: String) = println(msg)
}

常见误区

  • 期待对象声明带构造参数:对象无公开构造器,状态在对象体内部初始化。
  • 多个对象实现同一接口却共享状态:各自实例独立持有状态。

追问

  • 答:对象声明能否继承开放类并调用父类构造?答:可以,继承时按父类构造规则传参。
  • 答:接口默认方法在对象中如何处理?答:直接继承使用,需要改行为时覆盖。

04.8.1.2-019 嵌套类与 inner 类有什么区别?

一句话结论

嵌套类默认是静态内部类,不持有外部实例引用;inner 类是非静态内部类,持有外部实例引用,可访问外部类成员。

概念解释

Kotlin 嵌套类对应 Java 静态嵌套类;inner 对应 Java 内部类(非静态)。是否持有外部引用决定了访问能力与内存占用,也是内存泄漏的常见来源。

原理流程

  1. 普通嵌套类编译为独立静态类,无外部引用。
  2. inner 类构造时绑定外部实例,保存外部引用。
  3. inner 内可直接访问外部成员。
  4. 外部实例生命周期长于内部类时需注意引用持有。

代码或图示

class Outer {
    private val secret = 42

    class Nested { /* 不持有 Outer 引用 */ }
    inner class Inner {
        fun read() = secret // 访问外部实例成员
    }
}

常见误区

  • 把 Kotlin 嵌套类当作 Java 内部类:默认不持有外部引用。
  • 在不需要外部访问的场景用 inner:多余持有外部实例。

追问

  • 答:inner 类如何在外部实例外创建?答:必须先有外部实例,通过 outer.Inner() 形式构造。
  • 答:嵌套类能否访问外部 companion object 成员?答:可以,伴生成员属于类级别,不依赖外部实例。

04.8.1.2-020 inner 类对外部实例的访问规则是什么?

一句话结论

inner 类持有外部实例引用,可直接访问外部类的成员与属性;同名冲突时用 this@Outer 显式指定外部接收者。

概念解释

内部类的每个实例都绑定一个外部实例。访问外部成员不需要外部对象引用;当内部类自身成员与外部同名时,通过限定 this 消歧。

原理流程

  1. inner 实例构造时捕获外部 this。
  2. 成员解析先查内部类,再沿外部实例查找。
  3. 同名歧义用 this@Outer.member 指定外部。
  4. 外部私有成员对内部类可见。

代码或图示

class Window {
    private val title = "main"
    inner class TitleBar {
        val outerTitle = this@Window.title
    }
}

常见误区

  • 在 inner 内混淆两个 this:未限定导致访问到内部成员。
  • 内部类被长生命周期持有:外部实例无法回收。

追问

  • 答:inner 类能否声明伴生对象?答:内部类的静态成员受限,具体规则以编译器为准;类级别逻辑优先放外部类或嵌套类。
  • 答:外部私有属性为何内部类可访问?答:编译期为内部类开放外部私有成员访问通道。

04.8.1.2-021 内部类在 Java 互操作时的构造形态是什么?

一句话结论

inner 类在字节码上保存外部实例引用,Java 侧构造时需要先持有外部实例并按编译器生成规则传入;嵌套静态类则像普通静态类一样直接构造。

概念解释

互操作问题常出现在把 Kotlin inner 类暴露给 Java 或框架反序列化时:构造器签名包含外部实例依赖。理解引用持有有助于排查实例化失败与泄漏。

原理流程

  1. 嵌套类生成静态类,构造器无外部参数。
  2. inner 类构造器接收外部实例引用。
  3. Java 调用按生成签名传入外部对象。
  4. 框架无外部实例时无法直接实例化内部类。

代码或图示

class Container {
    inner class Item(val label: String)
}
// Java 侧:先拿 Container 实例,再按内部类构造规则创建 Item

常见误区

  • 把内部类当作可独立序列化的值对象:持有外部引用,序列化边界复杂。
  • 框架反射实例化 inner 类失败:缺少外部实例依赖。

追问

  • 答:需要独立构造的辅助类型应声明为什么?答:普通嵌套类或顶层类,不持有外部引用。
  • 答:内部类引用外部实例对内存有何影响?答:外部实例被内部类间接持有,内部类存活期间外部不可回收。

04.8.1.2-022 继承为什么需要显式 open?

一句话结论

Kotlin 类与成员默认 final,防止未经设计的继承扩展;只有显式 open、abstract 或接口成员才能被继承与重写。

概念解释

这是对 Java 可随意继承的收紧:类作者明确哪些扩展点开放。继承是强耦合关系,默认封闭减少误用。重写方法必须加 override,且不能降低可见性。

原理流程

  1. 编译器检查父类是否 open/抽象/接口。
  2. 子类声明继承关系。
  3. 被重写成员必须在父类可重写。
  4. 子类方法标注 override,签名兼容父类成员。

代码或图示

open class Message {
    open fun format(): String = "raw"
}

class JsonMessage : Message() {
    override fun format(): String = "{}"
}

常见误区

  • 忘记给父类加 open 就派生子类:编译报错。
  • 重写方法不加 override:编译器要求显式标注。

追问

  • 答:final 重写方法是什么含义?答:子类重写后可再标记 final,阻止继续向下重写。
  • 答:接口方法默认可重写吗?答:接口成员实现类必须或可覆盖,不受类成员 open 规则约束。

04.8.1.2-023 重写 override 的规则与可见性约束是什么?

一句话结论

重写方法必须标注 override,签名兼容父类成员;可见性不能比父类更严格,协变返回类型允许子类返回更具体类型。

概念解释

重写是多态的实现:子类方法替换父类实现。规则覆盖方法名、参数类型、返回类型与可见性。属性重写遵循类似约定,var/val 转换受限制。

原理流程

  1. 编译器匹配父类可重写成员。
  2. 检查参数类型与返回类型兼容。
  3. 检查可见性:子类方法不得更不可见。
  4. 标注 override 后进入虚方法表,运行时按实际类型分派。

代码或图示

open class Shape {
    open fun area(): Double = 0.0
}
class Circle : Shape() {
    override fun area(): Double = 3.14
}

常见误区

  • 子类方法与父类同名却不标 override:被视为新方法而非重写。
  • 把父类 val 重写为 var 或反向:属性重写有类型与可变性约束。

追问

  • 答:返回类型协变允许什么?答:子类返回父类返回类型的子类型。
  • 答:重写时能否抛出更宽异常?答:Kotlin 不强制受检异常声明,行为以 JVM 与调用方处理为准。

04.8.1.2-024 抽象类与接口成员如何使用?

一句话结论

抽象类用 abstract class,可含构造逻辑、状态与抽象成员;接口用 interface,定义行为契约,成员可为抽象或默认实现,不能持有构造状态。

概念解释

抽象类用于「is-a」且需要共享实现与状态的层级;接口用于能力契约,支持多实现。抽象成员无实现,子类必须覆盖;接口默认成员可直接复用。

原理流程

  1. 抽象类声明抽象属性/方法,无具体实现。
  2. 具体子类覆盖全部抽象成员后才可实例化。
  3. 接口声明方法与默认实现。
  4. 类通过冒号列表继承类并实现多个接口。

代码或图示

abstract class DataSource {
    abstract fun load(): List<String>
    fun common() = "shared"
}

interface Formatter {
    fun format(v: String): String
}

常见误区

  • 抽象类里写大量无状态纯契约:更适合拆为接口。
  • 实现接口却不覆盖抽象方法:编译报错。

追问

  • 答:一个类能继承几个抽象类?答:单继承,只能 extends 一个类;接口可实现多个。
  • 答:接口能否声明属性?答:可声明抽象属性或带默认 getter,不能存储幕后字段状态。

04.8.1.2-025 接口中的属性、默认方法与字段限制是什么?

一句话结论

接口可声明抽象属性或带 getter 的默认属性实现,但不能持有幕后字段与构造状态;方法可提供默认实现,类按需覆盖。

概念解释

接口保持行为契约定位:属性访问逻辑可默认给出,状态存储留给实现类。默认方法解决接口演进时的兼容问题,避免所有实现类被迫新增方法。

原理流程

  1. 接口属性无初始存储字段。
  2. 默认 getter 基于接口方法或常量计算。
  3. 默认方法提供通用实现。
  4. 实现类覆盖需要变化的成员。

代码或图示

interface Named {
    val name: String
    val upper: String get() = name.uppercase()
    fun describe() = "[$name]"
}

常见误区

  • 在接口里声明 var 状态字段:接口不能存储可变状态。
  • 依赖接口默认方法保存跨调用状态:状态应在实现类持有。

追问

  • 答:接口属性能否有 setter?答:接口属性实现受规则限制,可变状态由实现类定义。
  • 答:多接口同名默认方法冲突如何处理?答:实现类必须覆盖冲突成员并指定委托来源。

04.8.1.2-026 接口继承与多实现冲突如何处理?

一句话结论

类可实现多个接口,成员同名冲突时必须在类中覆盖,并通过 super<接口名>.成员 指定调用某一父接口实现;接口之间也可继承扩展。

概念解释

多接口带来菱形冲突风险。Kotlin 要求冲突成员由实现类裁决:提供自己的实现,并可选择复用某接口默认方法。接口继承可组合行为契约。

原理流程

  1. 类声明实现多个接口。
  2. 编译器检测同名同签名成员冲突。
  3. 实现类覆盖该成员消除歧义。
  4. 需要复用默认实现时用限定 super 调用。

代码或图示

interface A { fun msg() = "A" }
interface B { fun msg() = "B" }

class C : A, B {
    override fun msg() = super<A>.msg() + super<B>.msg()
}

常见误区

  • 多接口同名方法不覆盖:编译报错。
  • 普通 super.msg() 在冲突时歧义:必须限定接口名。

追问

  • 答:接口可以继承多个接口吗?答:可以,接口用冒号列表继承多个父接口并组合契约。
  • 答:方法参数不同是否构成冲突?答:重载共存,签名相同才需要裁决。

04.8.1.2-027 类层次构造调用顺序是怎样的?

一句话结论

实例化时先执行父类主构造器与初始化,再执行子类属性初始化与 init 块;父类初始化完成前,子类重写成员看到的状态可能未就绪。

概念解释

构造顺序保证父类 invariants 先建立。子类在父类构造期间调用开放方法时,方法可能被子类覆盖,而子类字段尚未初始化,是经典构造期陷阱。

原理流程

  1. 分配对象内存,字段置默认值。
  2. 执行父类构造参数、属性初始化与 init。
  3. 执行子类属性初始化与 init。
  4. 构造完成,返回实例。

代码或图示

open class Base {
    open val label = "base"
}
class Derived : Base() {
    override val label = "derived"
}

常见误区

  • 在父类构造期调用子类重写方法:子类状态未初始化,行为不确定。
  • 子类 init 假设父类开放成员已按子类逻辑就绪:实际仍是父类实现。

追问

  • 答:如何避免构造期开放方法陷阱?答:父类构造期不调用可重写方法,初始化逻辑延后到工厂方法或 init 完成后。
  • 答:属性初始化在构造期何时执行?答:按类体内顺序,父类先于子类。

04.8.1.2-028 data class 自动生成哪些成员?

一句话结论

data class 根据主构造属性自动生成 equals/hashCode、toString、copy、componentN 解构方法;业务对象只需声明属性即可获得值语义契约。

概念解释

data class 用于承载数据的不可变值对象。生成成员以主构造参数为准;类体中声明的属性不参与自动生成的相等性与解构。手写成员会覆盖对应生成实现。

原理流程

  1. 编译器识别 data 修饰与主构造属性。
  2. 生成基于属性的 equals/hashCode。
  3. 生成含属性列表的 toString。
  4. 生成 copy 与按属性顺序的 componentN。

代码或图示

data class User(val id: Long, val name: String)

val u = User(1, "Ann")
val copy = u.copy(name = "Anna")

常见误区

  • 把核心状态写在类体属性而非构造参数:自动生成成员不纳入该属性。
  • 在 data class 中混入可变行为:值语义被削弱。

追问

  • 答:手写 equals 会覆盖生成版本吗?答:会,手写实现替代编译器生成逻辑。
  • 答:componentN 顺序由什么决定?答:主构造参数声明顺序。

04.8.1.2-029 data class 的 equals/hashCode 契约是什么?

一句话结论

生成的相等性比较主构造属性的值内容,同类对象所有属性相等即视为相等;hashCode 基于相同属性计算,相等对象必须有相等哈希。

概念解释

值语义让 data class 可安全用于集合键与判等。参与比较的是构造属性值,可空属性按空安全规则比较。类层级与可变属性会影响契约稳定性。

原理流程

  1. equals 先判同引用,再比较类型与各构造属性。
  2. 所有属性相等返回 true。
  3. hashCode 组合参与相等性的属性。
  4. 放入 HashMap/HashSet 时按此契约分组。

代码或图示

data class Point(val x: Int, val y: Int)
println(Point(1, 2) == Point(1, 2)) // true

常见误区

  • 可变属性参与相等性:对象入集合后改值,哈希与分组失效。
  • 忽略类型层级对称性:子类实例与父类 data class 比较可能不对称。

追问

  • 答:可空属性如何参与比较?答:两侧都为空相等,一侧为空不等。
  • 答:集合元素要求什么契约?答:相等对象哈希相等,修改参与哈希的属性前需从集合移除。

04.8.1.2-030 data class 的 copy 如何修改属性?

一句话结论

copy 基于原实例复制一份,命名参数覆盖需要修改的属性,未传属性沿用原值;返回新实例,原对象不变。

概念解释

copy 支持不可变更新:链式修改通过多次 copy 生成新对象。属性顺序与命名参数对应,可空与默认值按构造规则处理。

原理流程

  1. 读取原实例各构造属性。
  2. 命名参数覆盖对应属性。
  3. 调用构造器创建新实例。
  4. 原实例保持不变。

代码或图示

data class Task(val title: String, val done: Boolean = false)
val t = Task("write docs")
val done = t.copy(done = true)

常见误区

  • copy 只复制引用:嵌套可变集合仍共享,深层修改需另行复制。
  • 覆盖类体属性:copy 只按构造参数工作。

追问

  • 答:嵌套 data class 如何整体更新?答:逐层 copy,或引入结构化更新工具;嵌套可变集合需单独深拷贝。
  • 答:copy 能改变对象类型吗?答:不能,返回同类实例。

04.8.1.2-031 data class 的 componentN 与解构声明如何配合?

一句话结论

编译器按构造参数顺序生成 component1()、component2() 等方法,解构声明按位置取值;修改构造参数顺序会破坏既有解构代码。

概念解释

解构让 data class 以 val (a, b) = instance 形式拆包。组件顺序与构造参数绑定,属于公开契约;重排参数需同步检查解构使用点。

原理流程

  1. 生成 componentN 返回第 N 个构造属性。
  2. 解构声明按位置调用组件方法。
  3. 各变量类型按组件返回类型推断。
  4. 组件数量不符时编译报错。

代码或图示

data class Pair2(val first: String, val second: Int)
val (key, value) = Pair2("k", 1)

常见误区

  • 依赖位置解构却不理解参数顺序:参数重排后变量语义错位。
  • 普通类未提供组件方法就解构:编译失败。

追问

  • 答:Map 条目解构基于什么?答:Map.Entry 提供 component1/component2 约定。
  • 答:解构跳过组件怎么写?答:对应位置用 _。

04.8.1.2-032 data class 的 toString 格式是什么?

一句话结论

生成的 toString 输出 类名(属性1=值1, 属性2=值2) 形式,便于日志调试;嵌套 data class 按其自身格式递归展开。

概念解释

默认字符串表示包含全部主构造属性,集合与可空值按其 toString 规则展示。生产日志中敏感字段需在类内覆盖 toString 脱敏。

原理流程

  1. 编译器生成拼接类名与属性键值的实现。
  2. 各属性值调用其字符串表示。
  3. 嵌套对象递归展开。
  4. 手写 toString 覆盖默认生成版本。

代码或图示

data class Order(val id: Long, val item: String)
// Order(id=1, item=book)

常见误区

  • 在日志里直接打印含密码、令牌的 data class:泄露敏感信息。
  • 依赖默认 toString 做业务序列化:格式不稳定,应使用专用序列化。

追问

  • 答:敏感字段如何脱敏?答:覆盖 toString 只输出非敏感字段,或使用专用日志模型。
  • 答:嵌套集合在 toString 中显示什么?答:按集合默认字符串表示展开。

04.8.1.2-033 data class 的构造参数有什么约束?

一句话结论

data class 主构造器至少包含一个参数,参数通常声明为 val/var 以参与生成成员;全纯参数不产生数据属性,失去 data class 意义。

概念解释

规则保证 data class 有可比较的数据状态。构造参数可带默认值与可空类型;类体属性不进入自动生成的相等性、解构与复制。

原理流程

  1. 主构造至少一个参数。
  2. 参与生成成员的参数带属性声明。
  3. 默认值与可空性按普通构造规则处理。
  4. 编译器校验参数与生成成员一致性。

代码或图示

data class Config(val timeout: Int = 30, val retry: Int = 3)

常见误区

  • data class 无构造属性:不满足使用前提。
  • 核心字段写在类体:自动生成成员不包含它。

追问

  • 答:data class 可以继承其他类吗?答:可以,但相等性对称性需额外注意,见后续题目。
  • 答:构造参数必须是 val 吗?答:推荐如此;纯参数不参与生成成员。

04.8.1.2-034 data class 继承普通类时 equals 有哪些对称性坑?

一句话结论

data class 继承父类时,生成的相等性若纳入父类属性或类型判断不当,容易出现 a == b 与 b == a 不一致;值类型通常不应参与开放继承层级。

概念解释

相等性契约要求对称:a.equals(b) 当且仅当 b.equals(a)。子类加入额外属性后,父类实例与子类实例比较容易违反对称性。

原理流程

  1. 子类 data class 生成比较逻辑。
  2. 父类 equals 未考虑子类附加状态。
  3. 双向比较路径不同导致结果不对称。
  4. 放入集合后相等性判断不稳定。

代码或图示

open class Item(val sku: String)
data class Book(val title: String, val sku: String) : Item(sku)
// 双向 equals 是否一致需要单独审查父类实现

常见误区

  • 让可扩展继承层级承载值对象:状态差异破坏对称契约。
  • 子类覆盖 equals 却不处理父类属性:比较漏项。

追问

  • 答:值对象推荐的继承方式?答:优先用组合或 sealed 层级,避免开放继承加入值语义。
  • 答:如何测试对称性?答:构造父类与子类实例,双向断言 == 结果一致。

04.8.1.2-035 data class 中使用可变属性有哪些风险?

一句话结论

可变属性破坏值对象不可变性:相等性参与字段被修改后,集合分组、缓存键与解构结果可能与预期不符;data class 优先使用 val。

概念解释

data class 的优势是稳定值语义。var 属性可在对象创建后改变,若该属性参与 equals/hashCode,放入 HashMap 后改值会导致元素定位错误。

原理流程

  1. 可变属性参与相等性计算。
  2. 对象入集合后属性被修改。
  3. 哈希值变化,原桶位无法找回元素。
  4. 业务缓存与去重判断出现不一致。

代码或图示

data class MutableCart(var items: MutableList<String>)
// 入集合后修改 items:相等性与哈希随之变化

常见误区

  • 在 data class 里暴露内部可变集合:外部可直接改状态。
  • 把需要变化的业务状态建模成 data class:应拆为可变领域对象。

追问

  • 答:必须可变时如何降低风险?答:可变属性不参与相等性,集合使用前移除再改值,或改用普通类。
  • 答:data class 属性可以是可变集合吗?答:语法允许,但建议公开只读视图,内部封装修改。

04.8.1.2-036 data class 在集合中的相等性表现如何?

一句话结论

放入 List、Set、Map 的 data class 按构造属性值比较:属性相同即视为同一元素,可用于去重与键查找;修改参与哈希的属性前必须从集合移除。

概念解释

List 按顺序与 equals 判等,Set 与 Map 键依赖 equals/hashCode。data class 的值语义让它适合作为集合元素,但可变属性会破坏这一前提。

原理流程

  1. 加入集合时计算哈希并按相等性查找位置。
  2. 查找元素时重新计算哈希并比较属性。
  3. 属性未变:定位与去重符合预期。
  4. 属性被修改:哈希变化,原集合条目可能无法找回。

代码或图示

val users = mutableSetOf(User(1, "Ann"))
println(User(1, "Ann") in users) // true

常见误区

  • 把可变 data class 长期作为 Map 键:改值后键失效。
  • 以为 Set 按对象身份去重:data class 按内容去重。

追问

  • 答:需要按身份区分实例用什么?答:普通类或身份标识字段,不依赖内容相等性。
  • 答:集合中修改对象的安全流程?答:先移除旧元素,改值后再加入。

04.8.1.2-037 嵌套 data class 的层级修改如何用 copy 链完成?

一句话结论

多层嵌套时从外层向内逐层 copy,需要变化的内层对象在对应层覆盖;每一层生成新实例,未修改的层级复用原引用。

概念解释

不可变更新没有「直接改深层字段」的语法糖,copy 链显式表达层级复制。嵌套可变集合不在 copy 深拷贝范围内,需要单独处理。

原理流程

  1. 外层对象 copy 时传入新的内层对象。
  2. 内层对象先基于原值 copy 覆盖目标字段。
  3. 逐层返回新实例。
  4. 未涉及的属性与嵌套对象沿用原引用。

代码或图示

data class Profile(val name: String, val address: Address)
data class Address(val city: String)

val p2 = p.copy(address = p.address.copy(city = "Kunming"))

常见误区

  • 以为 copy 深拷贝所有嵌套对象:只复制外层属性引用。
  • 长 copy 链可读性差:可提取领域方法封装层级更新。

追问

  • 答:嵌套集合如何整体替换?答:在对应层 copy 传入新集合实例;需要深拷贝时显式复制元素。
  • 答:哪些场景适合引入结构化更新库?答:层级深、更新点多的领域模型,评估依赖成本后再选。

04.8.1.2-038 data class 与 JVM 互操作时,无参构造与序列化有哪些注意点?

一句话结论

data class 默认按主构造参数生成构造器,框架反序列化常要求无参构造或字段访问;可空默认值、@JvmOverloads 与序列化配置需要配合评估。

概念解释

Java 框架、ORM、反射工具常依赖无参构造或 setter。Kotlin data class 构造集中在主构造器,互操作时可能需要默认值、注解辅助或专用序列化器。具体框架行为以目标库版本为准。

原理流程

  1. 编译器按构造参数生成构造器签名。
  2. 无默认值参数的构造器不提供无参形式。
  3. 框架通过构造器反射或字段注入重建对象。
  4. 序列化库按 Kotlin 构造器约定或注解映射字段。

代码或图示

data class Product(val id: Long, val name: String, val stock: Int = 0)
// 互操作与反序列化所需构造形态、注解以目标框架文档为准

常见误区

  • 假设所有 Java 框架都能直接实例化 Kotlin data class:构造约束可能不匹配。
  • 序列化依赖类体私有字段:需确认库是否支持 Kotlin 构造器重建。

追问

  • 答:如何为 Java 调用生成参数重载构造器?答:主构造参数加 @JvmOverloads,具体生成规则以编译器为准。
  • 答:待确认点写什么?答:标注目标框架版本、反序列化方式与需要实测的构造器签名。

04.8.1.2-039 sealed class 的定位与表达式穷尽性是什么?

一句话结论

sealed class 限制子类只能在编译可控范围内声明,构成封闭层级;配合 when 可在编译期检查分支是否穷尽,未覆盖分支会报错。

概念解释

sealed 用于建模有限取值的代数数据类型:状态、结果、树形结构等。子类集合封闭,编译器能枚举所有可能,when 不需要 else 兜底即可被判定穷尽。

原理流程

  1. 声明 sealed class,子类在同一模块/包内受限位置声明。
  2. 编译器记录完整子类集合。
  3. when 表达式按子类分支检查覆盖。
  4. 缺分支时编译报错,强制处理所有情形。

代码或图示

sealed class Result<out T>
data class Success<T>(val value: T) : Result<T>()
data class Failure(val error: Throwable) : Result<Nothing>()

fun <T> handle(r: Result<T>) = when (r) {
    is Success -> r.value
    is Failure -> "err"
}

常见误区

  • 把 sealed 当作普通抽象类开放任意继承:子类位置受封闭规则约束。
  • when 语句形式与表达式形式的穷尽检查区别对待:表达式要求更严格。

追问

  • 答:sealed 构造器可见性默认是什么?答:默认 private,具体规则以官方文档为准。
  • 答:sealed 能否被外部模块继承?答:受限,跨模块扩展规则见后续题目。

04.8.1.2-040 sealed interface 与 sealed class 有什么区别?

一句话结论

sealed interface 定义封闭的能力契约层级,可被多个 sealed class/普通类实现;sealed class 是封闭的类层级,自带继承状态与构造约束。2.x 中二者配合可建模更灵活的 ADT。

概念解释

sealed interface 适合「多种类型共享同一能力标记」,sealed class 适合「共享父类状态与实现」。一个类可实现多个 sealed interface,类层级仍保持封闭。

原理流程

  1. 声明 sealed interface 标记契约。
  2. 实现类/ sealed class 在允许范围内实现接口。
  3. 编译器封闭实现集合。
  4. when 按接口实现类型做穷尽分派。

代码或图示

sealed interface UiState
data object Loading : UiState
data class Content(val text: String) : UiState
data class Error(val msg: String) : UiState

常见误区

  • 混淆 sealed interface 与普通接口:实现集合受封闭约束。
  • 跨模块随意新增实现:破坏 sealed 层级封闭性。

追问

  • 答:sealed interface 在哪个版本后稳定可用?答:具体版本状态以 kotlinlang.org 官方文档为准,项目版本实测确认(待确认点)。
  • 答:data object 与 object 区别?答:data object 提供更合适的 toString 与相等性表现,详见标准库文档。

04.8.1.2-041 sealed 层级的子类权限与位置有哪些规则?

一句话结论

sealed 子类必须在 sealed 声明所在的受限位置(同包/同模块,按编译器版本规则)声明;外部不可随意扩展,子类可以是 class、data class、object、data object。

概念解释

封闭性是 sealed 的核心价值:编译器枚举子类集合。位置规则随语言版本演进,新版放宽了部分同模块约束;跨模块继承默认不允许,除非使用开放替代方案。

原理流程

  1. 编译器校验子类声明位置是否在允许范围。
  2. 子类继承 sealed 父类型。
  3. 记录子类到封闭层级表。
  4. 位置越界或外部扩展时编译报错。

代码或图示

sealed class Expr
data class Num(val n: Int) : Expr()
data class Sum(val l: Expr, val r: Expr) : Expr()

常见误区

  • 在第三方模块新增 sealed 子类:封闭规则不允许。
  • 子类位置分散导致 when 穷尽性难审查:集中在同一目录维护。

追问

  • 答:同包与同模块规则有何版本差异?答:以目标 Kotlin 版本官方文档为准,不确定处标注「待确认」并在编译工程验证。
  • 答:sealed 子类可以有自己的子类吗?答:可以继续层级派生,但整体仍受封闭规则约束。

04.8.1.2-042 when 对 sealed 类型如何做穷尽检查?

一句话结论

当 when 作用于 sealed 类型且每个直接子类都有对应分支时,编译器判定穷尽,表达式可省略 else;缺少任一子类分支即报错。

概念解释

穷尽检查把「漏处理一种状态」从运行时问题提前到编译期。sealed 父类型分支可用 is 检查;子类为单例对象时可直接匹配对象类型。

原理流程

  1. 编译器取得 sealed 层级全部子类。
  2. 扫描 when 分支覆盖的类型。
  3. 未覆盖子类列入诊断。
  4. 表达式形式要求穷尽,语句形式可保留兜底。

代码或图示

fun eval(e: Expr): Int = when (e) {
    is Num -> e.n
    is Sum -> eval(e.l) + eval(e.r)
}

常见误区

  • 给 sealed when 加无意义 else:掩盖未来新增子类的编译提醒。
  • 分支用类型判断却不做智能转换:访问子类成员需 is 后收窄。

追问

  • 答:枚举类型的穷尽检查同理吗?答:类似,枚举常量集合封闭,when 表达式可检查全部常量。
  • 答:sealed 层级新增子类后会发生什么?答:未覆盖的 when 表达式编译报错,强制补充分支。

04.8.1.2-043 sealed 与枚举如何对比选型?

一句话结论

枚举是固定常量集合,每个常量是单例;sealed 子类可以携带不同结构与状态,支持 data class、object 混合。取值固定且无附加数据用枚举,状态带载荷用 sealed。

概念解释

枚举常量共享同一类型结构,不能各自带不同字段;sealed 每个子类可有独立属性与方法。两者都支持 when 穷尽检查,选型看取值是否需要携带数据。

原理流程

  1. 判断候选取值是否需要附加状态:不需要用枚举。
  2. 不同取值携带不同字段/结构:用 sealed 层级。
  3. 枚举常量为单例,sealed 子类可实例化多个对象。
  4. 两者都配合 when 做编译期穷尽分派。

代码或图示

enum class Direction { NORTH, SOUTH, EAST, WEST }

sealed class Event
data class Click(val x: Int, val y: Int) : Event()
data object Close : Event()

常见误区

  • 用枚举携带可变字段:常量单例状态被共享。
  • 简单固定标记强行用 sealed:枚举更轻量直观。

追问

  • 答:枚举能否实现接口?答:可以,枚举常量可实现接口方法。
  • 答:sealed 子类可以是枚举吗?答:组合形式受语言规则限制,具体以编译器版本为准(待确认)。

04.8.1.2-044 sealed 在建模代数数据类型(ADT)中扮演什么角色?

一句话结论

sealed 把「有限种取值 + 每种取值携带不同数据」表达为类型层级,配合 when 做模式分派,是 Kotlin 表达 ADT 的主要手段。

概念解释

ADT 由乘积类型(data class 组合字段)与和类型(sealed 选择分支)构成。sealed 定义和类型分支,data class 定义分支载荷,编译器保证分支完整处理。

原理流程

  1. 顶层 sealed 描述所有可能情形。
  2. 各子类定义自身字段结构。
  3. 业务代码用 when 按分支处理。
  4. 新增情形时编译期强制更新处理逻辑。

代码或图示

sealed class Payment
data class Card(val number: String, val cvv: String) : Payment()
data class Wallet(val address: String) : Payment()
data object Cash : Payment()

常见误区

  • 用嵌套可空类型表达分支:状态组合爆炸,缺少穷尽检查。
  • sealed 分支混入无关行为:和类型应聚焦数据形态。

追问

  • 答:乘积类型在 Kotlin 怎么表达?答:data class 组合多个字段。
  • 答:递归 ADT(如树)如何声明?答:子类引用父类型自身,形成递归结构。

04.8.1.2-045 sealed 子类可以混合哪些类型?

一句话结论

sealed 子类可以是普通 class、data class、object、data object;带载荷的分支用 data class,无状态单例分支用 object/data object。

概念解释

混合类型让层级同时承载「多实例数据」与「单例标记」。data object 为无状态分支提供规范的字符串表示与相等性;具体可用形式以编译器版本为准。

原理流程

  1. 需要携带字段:声明 data class 子类。
  2. 无状态标记:声明 object 或 data object。
  3. 需要自定义行为与状态:普通 class 子类。
  4. 编译器统一纳入封闭层级表。

代码或图示

sealed class Status
data class Active(val since: Long) : Status()
data object Inactive : Status()

常见误区

  • 无状态分支也写成 data class:产生多余实例与字段。
  • 忽略 data object 的标准库版本要求:低版本需用 object 替代。

追问

  • 答:data object 解决了 object 什么问题?答:默认 toString 与相等性表现更符合数据语义,详见官方文档。
  • 答:子类能否带构造默认值?答:可以,按普通类构造规则处理。

04.8.1.2-046 value class 的语义与装箱消除原理是什么?

一句话结论

value class 包装单个基础值,在满足内联条件时编译器消除包装对象,直接用底层类型表示;既获得类型安全区分,又避免额外对象开销。

概念解释

value class 是内联类的稳定形式(历史名称 inline class)。构造期包装底层值,使用点按规则展开为原始值。它解决「用字符串区分 UserId 与 OrderId」这类类型混淆问题。

原理流程

  1. 声明 value class X(val value: 基础类型)。
  2. 满足内联条件时,编译产物直接使用底层类型。
  3. 不满足条件(可空、泛型实参等)时退化为装箱表示。
  4. 运行时按包装类型做编译期区分,按底层类型存储。

代码或图示

@JvmInline
value class UserId(val value: String)

fun load(id: UserId) { /* 不能误传普通字符串 */ }

常见误区

  • 以为 value class 在所有场景都零开销:进入泛型、可空边界会装箱。
  • 用 value class 包装多个字段:value class 只能包装单个值。

追问

  • 答:@JvmInline 注解是否必需?答:按当前语言规则标注,具体注解要求以官方文档为准(待确认)。
  • 答:value class 能否继承类?答:实现接口可以,继承普通类受限,规则以文档为准。

04.8.1.2-047 value class 暴露给 JVM 的表示规则是什么?

一句话结论

内联条件满足时,JVM 签名优先使用底层类型;包装类型信息通过编译期类型检查与必要注解保留,跨语言边界可能看到底层类型而非包装类。

概念解释

理解表示规则有助于排查互操作、反射与序列化问题。value class 在源码层是独立类型,字节码层按内联/装箱两种形态出现;边界处类型可能被抹平。

原理流程

  1. 编译器判断使用点是否满足内联条件。
  2. 满足:方法签名与局部变量使用底层类型。
  3. 不满足:生成包装类实例。
  4. 跨语言调用按生成签名呈现,包装语义不强制保留到 JVM 类型系统。

代码或图示

value class OrderId(val value: Long)
// JVM 侧方法签名可能直接呈现 long,包装区分由 Kotlin 编译期保证

常见误区

  • 反射时期待拿到 value class 的独立类对象:内联点可能只看到底层类型。
  • Java 侧把底层值当作可随意替换的普通值:丢失 Kotlin 侧类型约束。

追问

  • 答:哪些位置会破坏内联?答:可空类型、作为泛型实参、暴露为可空对象等,详见后续题目。
  • 答:value class 方法在字节码上如何调用?答:按内联或装箱形态生成对应方法,以编译产物为准。

04.8.1.2-048 value class 如何做类型安全建模?

一句话结论

把基础类型包装成独立类型后,编译器阻止 UserId 与 OrderId 混用,函数参数只接受对应包装类型,避免字符串/长 ID 传错位置。

概念解释

裸 String/Long 在多层业务中容易混淆:用户 ID、订单 ID、手机号都是字符串。value class 在编译期建立类型边界,IDE 与编译器共同拦截误传。

原理流程

  1. 为每种标识声明独立 value class。
  2. 函数签名使用包装类型而非裸基础类型。
  3. 编译器检查实参类型匹配。
  4. 内部业务方法通过 .value 取底层值。

代码或图示

@JvmInline value class UserId(val value: Long)
@JvmInline value class OrderId(val value: Long)

fun userRepo(id: UserId)
fun orderRepo(id: OrderId)
// userRepo(OrderId(1)) 编译错误

常见误区

  • 函数内部仍接收裸类型再包装:边界约束失效。
  • 为每个临时字符串都建 value class:类型膨胀,按业务核心标识建模。

追问

  • 答:value class 能否定义业务校验?答:可以在 init 或方法中校验底层值,但注意内联与初始化成本。
  • 答:相等性比较基于什么?答:基于包装的底层值,详见后续题目。

04.8.1.2-049 value class 的相等性与身份比较是什么规则?

一句话结论

value class 按包装值做值相等性比较;内联场景下对象身份被消除,=== 身份比较语义受限,业务判等应使用 ==。

概念解释

值语义意味着两个包装相同底层值的实例相等。内联消除后不存在稳定包装对象身份,反射、哈希、集合行为需按值类型理解。

原理流程

  1. == 比较底层值是否相等。
  2. 内联表示下包装对象不固定存在。
  3. === 身份比较不适合作为业务判断依据。
  4. 集合哈希按值类型规则计算。

代码或图示

value class Email(val value: String)
println(Email("a@x.com") == Email("a@x.com")) // true

常见误区

  • 用 === 判断 value class 实例身份:内联场景身份不稳定。
  • 在 value class 中持有可变状态:破坏值语义与内联条件。

追问

  • 答:value class 能作为 HashMap 键吗?答:可以按值语义使用,但需注意装箱与哈希行为在边界处的表现。
  • 答:两个不同 value class 类型能否 ==?答:类型不同,编译期不视为兼容相等。

04.8.1.2-050 value class 作为泛型实参时有什么装箱坑?

一句话结论

value class 进入泛型容器(如 List<UserId>)时无法继续内联,元素退化为装箱包装对象;性能敏感的大容器需评估装箱成本。

概念解释

JVM 泛型擦除要求元素为对象表示,底层原始类型不能直接存入泛型容器。编译器在此边界装箱 value class,包装对象随元素创建。

原理流程

  1. 声明 List<UserId> 等泛型使用点。
  2. 擦除约束要求元素为引用类型。
  3. 编译器为 value class 生成装箱实例。
  4. 遍历与访问按包装对象进行。

代码或图示

value class UserId(val value: Long)
val ids: List<UserId> = listOf(UserId(1), UserId(2)) // 元素装箱

常见误区

  • 泛型集合中期待零包装对象:容器场景必然装箱。
  • 高频创建短生命周期 value class 进集合:关注分配压力。

追问

  • 答:可空 value class 为什么装箱?答:可空需要包装 null 与实例,原始类型不能承载空值。
  • 答:性能优化方向?答:大数值场景评估专用原始类型数组,或批量处理时减少包装对象存活。

04.8.1.2-051 value class 在序列化与反射场景有哪些限制?

一句话结论

序列化与反射依赖类型信息与对象实例,value class 内联消除会使包装类型在边界被抹平;需要确认序列化库是否支持包装类重建,必要时改用普通 data class。

概念解释

框架通常按类名、构造器、字段映射数据。value class 在 JVM 侧表示可能是底层类型,反射拿到的类型信息受限;不同序列化库支持程度不同,必须在目标版本实测。

原理流程

  1. 序列化库读取对象类型与构造器。
  2. 内联点只暴露底层类型,包装元数据可能缺失。
  3. 重建时需要库识别 value class 约定。
  4. 不支持时改为普通包装类或专用 DTO。

代码或图示

value class UserId(val value: String)
// 序列化输出格式、反序列化重建方式以所用库版本为准;不确定处标注待确认

常见误区

  • 假设所有 JSON/持久化库原生支持 value class:需逐库验证。
  • 反射按包装类名查找类型:内联边界可能找不到独立类。

追问

  • 答:跨边界传值时如何稳妥?答:在 API 层用普通 data class/DTO 承载,进入领域层再包装为 value class。
  • 答:待确认验证点写什么?答:库版本、序列化配置、正反序列化结果与反射类型表现。

04.8.1.2-052 value class 与 typealias 如何选型?

一句话结论

需要编译期类型区分、防止基础值混用选 value class;只需要简化长泛型或函数类型签名选 typealias;别名不产生独立类型,值类在满足条件时消除装箱。

概念解释

两者都基于单一基础类型,但安全强度不同:别名完全等价原类型,值类是独立类型。选型看是否需要阻止不同业务值互相赋值。

原理流程

  1. 评估是否需要类型混淆防护:不需要用别名。
  2. 需要防护:选 value class,评估装箱与序列化限制。
  3. 别名在编译期名称替换。
  4. 值类参与独立类型检查与值语义。

代码或图示

typealias JsonBody = String              // 不区分场景
@JvmInline value class JsonBody(val raw: String) // 独立类型

常见误区

  • 用别名做标识类型:普通字符串仍可传入。
  • 无类型区分需求也用值类:承担装箱与框架兼容成本。

追问

  • 答:值类需要多个字段时怎么办?答:value class 只能包装单值,多字段建模用 data class。
  • 答:别名能否扩展方法?答:可通过扩展函数补充,类型仍等价原类型。

04.8.1.2-053 enum class 的成员、valueOf 与 entries 如何使用?

一句话结论

枚举常量在类体内声明,可带构造参数与方法;entries 提供常量列表,按名称查找用 valueOf,未匹配抛异常。

概念解释

枚举是固定常量集合,每个常量是单例。常量可实现接口方法、携带属性;标准库按版本提供常量访问 API,旧版常用 values(),新版推荐 entries(具体可用性以版本为准,待确认)。

原理流程

  1. 枚举声明参数与成员。
  2. 常量列表由编译器固定生成。
  3. entries/values 遍历全部常量。
  4. valueOf 按名称匹配,无匹配抛 IllegalArgumentException。

代码或图示

enum class Color(val rgb: Int) {
    RED(0xFF0000), GREEN(0x00FF00), BLUE(0x0000FF);
}

val all = Color.entries
val red = Color.valueOf("RED")

常见误区

  • 遍历失败时静默返回 null:valueOf 不匹配直接抛异常,需要安全查找用 entries.find。
  • 枚举常量携带可变字段:单例状态被所有访问点共享。

追问

  • 答:entries 与 values 区别?答:entries 返回只读列表视图,values 历史上返回新数组;具体类型以标准库版本为准。
  • 答:枚举能否反序列化未知名称?答:按名称匹配需处理异常,或用默认分支兜底。

04.8.1.2-054 枚举常量的匿名类体如何使用?

一句话结论

枚举常量可声明匿名类体覆盖枚举方法,为每个常量提供不同实现;常量体在分号后书写,适合同一行为的不同分支实现。

概念解释

枚举不仅是标记,也可携带多态行为。各常量覆盖方法形成策略表;公共逻辑留在枚举基类,差异实现放入匿名体。

原理流程

  1. 枚举声明开放或抽象方法。
  2. 常量后接 { ... } 类体覆盖方法。
  3. 每个常量绑定自身实现。
  4. 调用方通过枚举类型多态分派。

代码或图示

enum class Operator {
    ADD { override fun apply(a: Int, b: Int) = a + b },
    MUL { override fun apply(a: Int, b: Int) = a * b };
    abstract fun apply(a: Int, b: Int): Int
}

常见误区

  • 在枚举匿名体中保存跨调用可变状态:常量单例状态共享。
  • 行为分支复杂时仍塞枚举体:复杂策略应拆为独立类。

追问

  • 答:枚举能否实现接口?答:可以,接口方法在枚举基类或匿名体实现。
  • 答:匿名体能否访问枚举构造参数?答:可以,通过构造传入的属性访问。

04.8.1.2-055 枚举与 when 的穷尽检查如何工作?

一句话结论

when 表达式作用于枚举时,编译器检查所有常量是否被分支覆盖;遗漏常量即报错,可省略 else,新增常量时强制更新分支。

概念解释

枚举常量集合封闭,穷尽检查与 sealed 同理。枚举分支可直接匹配常量名;带参数行为通常封装在枚举方法内,when 只做类型/常量分派。

原理流程

  1. 编译器取得枚举全部常量。
  2. 扫描 when 分支匹配的常量。
  3. 未覆盖常量列入诊断。
  4. 表达式形式要求穷尽后才可作为值使用。

代码或图示

fun label(d: Direction): String = when (d) {
    Direction.NORTH -> "上"
    Direction.SOUTH -> "下"
    Direction.EAST -> "右"
    Direction.WEST -> "左"
}

常见误区

  • 给枚举 when 留 else 吞掉新常量:失去编译提醒价值。
  • 分支内写重复行为:优先把行为下沉到枚举方法。

追问

  • 答:枚举新增常量后旧代码会怎样?答:穷尽 when 编译报错,提示补充分支。
  • 答:语句形式的 when 是否强制穷尽?答:表达式形式强制,语句形式按编译器规则处理。

04.8.1.2-056 sealed 与枚举组合使用的现状如何?

一句话结论

枚举适合固定无载荷常量,sealed 适合带载荷分支;二者可通过接口实现协同,枚举实现 sealed interface 是常见组合,具体语法边界以目标版本文档为准。

概念解释

业务状态常混合「固定枚举标记」与「携带数据分支」。让枚举实现 sealed interface,可在同一 when 层级统一分派;是否允许 sealed 子类为枚举受语言规则限制。

原理流程

  1. 定义 sealed interface 作为顶层标记。
  2. 无数据枚举常量实现该接口。
  3. 带数据分支用 data class 实现接口。
  4. when 按统一封闭层级处理。

代码或图示

sealed interface Status
enum class SyncStatus : Status { PENDING, DONE }
data class Failed(val reason: String) : Status

常见误区

  • 把版本不确定的组合语法写成确定结论:应标注「待确认」并在编译版本验证。
  • 过度组合层级:简单场景直接枚举或 sealed 即可。

追问

  • 答:验证点包含什么?答:编译是否通过、when 穷尽检查是否生效、反编译签名形态。
  • 答:官方参考文档在哪里?答:kotlinlang.org sealed 与枚举章节。

04.8.1.2-057 属性初始化顺序与未初始化访问异常是什么关系?

一句话结论

属性按类体顺序初始化,init 块交错执行;在赋值前访问 lateinit 或未初始化属性会抛专用异常,父类构造期访问子类属性也可能读到未就绪状态。

概念解释

构造期状态按顺序建立,访问顺序错误是常见 bug 来源。编译器对部分未初始化检查给出诊断,反射或 lateinit 场景在运行时暴露异常。

原理流程

  1. 对象内存分配,字段取默认值。
  2. 按类体顺序执行属性初始化器与 init。
  3. 提前访问未赋值属性:读到默认值或抛异常。
  4. 构造完成后属性才可安全使用。

代码或图示

class Demo {
    val a: Int = compute()
    val b: Int = a + 1
}

常见误区

  • init 中引用后面才初始化的属性:读到零值。
  • 父类开放方法在构造期被子类覆盖:子类属性尚未初始化。

追问

  • 答:lateinit 未初始化访问异常类型?答:UninitializedPropertyAccessException。
  • 答:如何排查构造期读到默认值?答:检查属性书写顺序与 init 引用位置,必要时延后初始化。

04.8.1.2-058 构造器注入与字段注入在 Kotlin 中如何写?

一句话结论

构造器注入把依赖作为主构造参数,编译期保证依赖就绪;字段注入通过 lateinit 属性配合框架反射赋值,依赖在构造后由容器填充。

概念解释

构造注入利于不可变与测试,依赖在对象创建时确定;字段注入解耦构造与容器,但属性可空/延后初始化,需处理未就绪状态。Spring、Koin 等框架两种方式都支持。

原理流程

  1. 构造注入:依赖写入主构造参数或属性。
  2. 对象创建时依赖已传入。
  3. 字段注入:声明 lateinit 可空属性,容器反射赋值。
  4. 使用前确认依赖已注入,避免未初始化访问。

代码或图示

// 构造注入
class UserService(private val repo: UserRepository)

// 字段注入
class OrderService {
    @Inject lateinit var repo: OrderRepository
}

常见误区

  • 字段注入属性在构造期被使用:容器尚未赋值。
  • 构造注入依赖链过深:审查对象组装边界。

追问

  • 答:测试时哪种注入更易替换 mock?答:构造注入直接传 mock 实现;字段注入需容器或反射赋值。
  • 答:框架注解写法以什么为准?答:所用 DI 框架版本文档,Koin/Spring 注解差异分别核对。

04.8.1.2-059 不可变对象建模有哪些原则?

一句话结论

属性用 val,集合暴露只读视图,不提供修改入口,相等性基于稳定字段;对象创建后状态不变,便于并发共享与值语义推理。

概念解释

不可变对象降低并发可见性问题,避免被外部意外修改。建模时区分「状态对象」与「命令/事件对象」,后者常设计为不可变 data class。

原理流程

  1. 声明只读属性,避免 var 状态。
  2. 内部可变集合通过只读属性暴露。
  3. 修改通过返回新实例(copy)完成。
  4. 相等性与哈希基于不可变字段。

代码或图示

data class ImmutableOrder(val id: Long, val items: List<LineItem>)

常见误区

  • 公开 MutableList 属性:外部可绕过方法改状态。
  • 不可变对象内持有可变外部引用:内部状态被间接改写。

追问

  • 答:不可变集合在 Kotlin 如何获得?答:listOf/setOf 等工厂返回只读接口视图。
  • 答:需要更新时怎么办?答:生成新实例并替换引用,旧实例保持不变。

04.8.1.2-060 类可见性与文件可见性如何划分?

一句话结论

类成员 private 限定类内,顶层声明 private 限定文件内;protected 用于类成员及子类,internal 限定模块,public 默认可见。

概念解释

Kotlin 可见性边界按文件、类、模块三层组织。顶层函数/属性的私有边界是文件,不要与 Java 包私有混淆。可见性在编译期检查。

原理流程

  1. 声明位置确定可用边界集合。
  2. 引用点检查是否在允许边界内。
  3. 子类不能放宽父类成员可见性。
  4. 跨模块源码引用 internal 被拒绝。

代码或图示

private fun fileHelper() {}      // 文件内可见

class Box {
    private val secret = 1       // 类内可见
    protected open val tag = "x" // 类与子类可见
}

常见误区

  • 把顶层 private 当类私有理解。
  • 子类把 protected 成员改为 public 过度暴露。

追问

  • 答:Kotlin 有没有包私有可见性?答:没有 Java 式包私有,模块内用 internal。
  • 答:可见性与重写规则?答:重写成员不能比被重写成员更不可见。

04.8.1.2-061 open 属性与 getter 重写如何工作?

一句话结论

属性加 open 后子类可重写 getter;val 属性可被子类保持 val 重写,var 重写受可变性约束,重写属性标注 override。

概念解释

属性重写本质是访问器重写。父类开放属性提供默认 getter/setter,子类覆盖访问逻辑。属性类型与可变性必须兼容父类声明。

原理流程

  1. 父类属性声明 open。
  2. 子类用 override 声明同名属性。
  3. 覆盖 getter/setter 实现。
  4. 运行时按实例类型分派访问器。

代码或图示

open class Base {
    open val name: String = "base"
}
class Derived : Base() {
    override val name: String = "derived"
}

常见误区

  • 父类 val 子类改写成 var:可变性放宽受限。
  • 重写属性不调父类逻辑却丢失原约定:审查语义兼容。

追问

  • 答:属性重写可以改变类型吗?答:允许协变收窄,具体兼容规则以编译器检查为准。
  • 答:抽象属性如何实现?答:父类声明无初始化值的抽象属性,子类必须覆盖提供实现。

04.8.1.2-062 重写属性时的类型协变边界是什么?

一句话结论

子类重写属性可返回父类型的子类型(协变),但不能换成不相关类型;只读属性协变更宽松,可变属性的 setter 方向受逆变约束。

概念解释

返回位置允许子类型替换父类型;写入位置则要求参数类型兼容父类约定。属性同时有 getter 与 setter 时,两个方向都要满足。

原理流程

  1. 编译器比较父类与子类属性类型。
  2. getter 返回类型支持协变:子类型可用。
  3. setter 参数方向要求兼容父类写入约定。
  4. 不兼容类型重写编译报错。

代码或图示

open class Animal
class Cat : Animal()

open class Cage {
    open fun animal(): Animal = Animal()
}
class CatCage : Cage() {
    override fun animal(): Cat = Cat()
}

常见误区

  • 可变属性两端都按协变理解:setter 方向规则不同。
  • 用不相关类型覆盖:类型不兼容报错。

追问

  • 答:方法返回协变与属性协变规则一致吗?答:思路一致,返回位置允许子类型。
  • 答:逆变在参数位置如何体现?答:函数参数方向接受父类型,详见泛型章节型变部分。

04.8.1.2-063 抽象属性的实现规则是什么?

一句话结论

抽象类中可声明无初始化值的抽象属性,子类必须覆盖提供 getter/存储实现;抽象属性不能有幕后字段初始值。

概念解释

抽象属性把「子类必须提供该状态/派生值」写成契约。父类可在方法中使用抽象属性,具体实现由子类补全。

原理流程

  1. 父类用 abstract val/var 声明属性,无初始值。
  2. 子类用 override 覆盖并提供实现。
  3. 未覆盖的子类仍是抽象类。
  4. 抽象属性访问器在父类方法中按多态分派。

代码或图示

abstract class View {
    abstract val label: String
    fun render() = "[$label]"
}
class Button : View() {
    override val label = "ok"
}

常见误区

  • 抽象属性在父类给默认值:与抽象语义矛盾。
  • 具体子类漏覆盖抽象属性:编译报错。

追问

  • 答:抽象 var 属性子类如何实现?答:覆盖为带 getter/setter 的可变属性。
  • 答:接口属性与抽象属性区别?答:接口可带默认 getter,抽象属性无实现要求。

04.8.1.2-064 伴生对象扩展与 JVM 静态扩展有哪些限制?

一句话结论

Kotlin 可为伴生对象或类写扩展函数补充类级逻辑,但 Java 侧不会自动看到这些扩展;@JvmStatic 只作用于伴生对象内声明的成员,扩展不能变成 Java 静态方法。

概念解释

扩展函数在编译期静态解析,不改变类对象结构。互操作时 Java 调用方需要直接访问类或伴生实例,扩展方法需以工具函数形式暴露。

原理流程

  1. 声明伴生对象或类的扩展函数。
  2. Kotlin 源码内按扩展语法调用。
  3. 编译为静态工具方法形态。
  4. Java 侧不能通过类名像静态成员一样直接调用该扩展。

代码或图示

class Repo {
    companion object {}
}

fun Repo.Companion.health(): String = "ok"
// Java 侧需通过生成的工具函数调用,不能写 Repo.health()

常见误区

  • 以为伴生扩展自动生成静态签名:扩展与声明成员是两回事。
  • 在扩展里访问伴生私有状态:扩展接收者权限受限。

追问

  • 答:如何向 Java 暴露类级工具?答:声明为伴生对象成员并加 @JvmStatic,或顶层函数配合 @JvmName。
  • 答:扩展能否覆盖伴生已有方法?答:成员方法优先于扩展,同名时解析规则以编译器为准。

04.8.1.2-065 类委托 by 与委托属性如何区分?

一句话结论

类委托 by 把整个接口实现代理给一个对象,自动生成接口方法转发;委托属性 by 代理单个属性的读写访问,二者 by 关键字语义不同。

概念解释

类委托是组合语法糖:声明 class Delegated : Interface by delegate,编译器生成接口方法调用 delegate 对应方法。委托属性代理属性 get/set。

原理流程

  1. 类声明实现接口并指定委托对象。
  2. 编译器为接口每个方法生成转发方法。
  3. 委托对象缺失的成员由类自身覆盖补充。
  4. 属性委托则在读写点转发到 getValue/setValue。

代码或图示

class CountingList<T>(private val inner: MutableList<T>) : MutableList<T> by inner {
    var additions = 0
    override fun add(element: T): Boolean {
        additions++; return inner.add(element)
    }
}

常见误区

  • 把类委托当成继承:委托是组合,不建立父类子类型关系之外的实现继承。
  • 委托对象状态被外部共享修改:装饰行为与内部状态耦合。

追问

  • 答:类委托需要实现接口全部方法吗?答:转发由编译器生成,仅需覆盖需要改造的成员。
  • 答:委托属性约定方法见哪题?答:见本节自定义委托属性题目。

04.8.1.2-066 类委托如何体现「组合优于继承」?

一句话结论

类委托把复用逻辑放入被委托对象,外层类只增强少量行为,避免继承层级膨胀与父类实现细节耦合;需要多个能力时可委托多个对象。

概念解释

继承强耦合父类内部实现,委托通过接口持有组件。外层类保留自身状态与扩展点,被委托对象提供通用行为,替换实现不影响外层类型。

原理流程

  1. 识别可复用行为对应的接口。
  2. 用具体对象实现接口并作为委托组件。
  3. 外层类声明接口并 by 委托。
  4. 覆盖需要计数、校验、日志的成员。

代码或图示

interface DataSink { fun write(line: String) }
class TeeSink(private vararg val sinks: DataSink) : DataSink by sinks.first() {
    override fun write(line: String) = sinks.forEach { it.write(line) }
}

常见误区

  • 委托多个对象却只转发接口:附加行为需在覆盖方法中组合。
  • 被委托对象生命周期长于外层:注意资源释放。

追问

  • 答:委托与装饰器模式关系?答:类委托是装饰器的语法简化,包装对象实现同一接口。
  • 答:委托能否访问被委托对象私有成员?答:不能,只能通过接口公开成员交互。

04.8.1.2-067 装饰器在 Kotlin 中如何简写?

一句话结论

传统装饰器需手写接口转发方法,Kotlin 类委托 by 自动生成全部转发,只覆盖需要增强的方法,样板代码大幅减少。

概念解释

装饰器围绕同一接口包装原对象,增加日志、计数、缓存等行为。委托语法把「逐方法转发」交给编译器,外层类聚焦差异逻辑。

原理流程

  1. 定义统一接口。
  2. 被包装对象实现接口。
  3. 装饰类 by 委托原对象。
  4. 覆盖方法插入前后置逻辑并调用委托对象。

代码或图示

class LoggingList<T>(private val inner: List<T>) : List<T> by inner {
    override fun get(index: Int): T {
        println("get $index")
        return inner[index]
    }
}

常见误区

  • 覆盖方法忘记调用委托对象:原行为丢失。
  • 装饰器暴露内部可变引用:绕过装饰逻辑直接操作原对象。

追问

  • 答:委托生成的转发方法调用谁?答:调用被委托对象的对应接口方法。
  • 答:多个装饰器嵌套顺序如何影响行为?答:按包装顺序逐层前后置,注意执行方向。

04.8.1.2-068 接口代理生成的字节码有什么特点?

一句话结论

类委托为接口每个方法生成转发方法,方法体内调用委托对象对应方法;字节码中外层类仍是接口实现类型,实例持有委托对象引用。

概念解释

理解生成形态有助于排查委托失效、方法查找与性能问题。转发方法是普通虚方法,运行时按外层实例分派后再转发到组件。

原理流程

  1. 编译器扫描委托类实现的接口方法。
  2. 为每个方法生成转发实现。
  3. 方法体读取委托字段并调用同名方法。
  4. 覆盖方法保留外层自定义逻辑。

代码或图示

class Wrap(val base: Map<String, String>) : Map<String, String> by base
// 字节码中 Wrap 实现 Map 方法,转发到 base

常见误区

  • 以为委托在运行时动态查找:转发方法在编译期固定生成。
  • 委托字段被替换后转发指向新对象:确认外层是否持有可变引用。

追问

  • 答:委托方法有额外开销吗?答:多一层方法调用转发,热点路径可实测对比。
  • 答:委托对象为 null 会怎样?答:转发时解引用失败,按空安全规则处理。

04.8.1.2-069 单例 object 的初始化时机与线程安全如何保证?

一句话结论

object 实例在类加载/首次访问阶段由 JVM 静态初始化机制创建,多线程下只初始化一次;内部可变状态的并发读写仍需自行保护。

概念解释

对象声明对应饿汉单例,构造逻辑在对象体与 init。JVM 类加载规范保证静态初始化的排他性,不需要手写同步块。状态共享带来的可见性问题另算。

原理流程

  1. 编译器生成单例类与静态实例字段。
  2. 类加载时执行对象体初始化。
  3. 多线程首次访问阻塞至初始化完成。
  4. 后续访问共享同一实例。

代码或图示

object Counter {
    private var count = 0
    @Synchronized fun next(): Int = ++count
}

常见误区

  • 以为单例内部变量天然线程安全:初始化安全不等于读写安全。
  • 单例持有 Activity/请求级引用:跨生命周期泄漏。

追问

  • 答:需要懒加载单例怎么做?答:伴生对象内用 lazy 委托或工厂方法按需创建。
  • 答:单例初始化抛异常会怎样?答:类初始化失败,后续访问按 JVM 类加载错误规则表现。

04.8.1.2-070 object 表达式中的局部单例与捕获规则是什么?

一句话结论

匿名对象表达式创建局部实例,可捕获外层变量;被捕获变量按闭包规则被对象持有,对象存活期间外层变量不会被回收。

概念解释

与全局 object 声明不同,对象表达式每次执行创建新实例。常用于临时回调、策略对象;捕获长生命周期变量是内存泄漏来源之一。

原理流程

  1. 执行到 object : 类型 {} 表达式创建实例。
  2. 闭包捕获引用的外层变量。
  3. 对象方法通过捕获引用访问外层值。
  4. 对象被长生命周期持有后,捕获引用一并留存。

代码或图示

fun register(handler: String) {
    val listener = object : Action {
        override fun run() = println(handler)
    }
    bus.subscribe(listener)
}

常见误区

  • 匿名对象订阅长生命周期总线却不反注册:捕获引用泄漏。
  • 期待对象表达式复用同一实例:每次执行新建。

追问

  • 答:捕获的是值还是引用?答:按闭包规则持有变量引用,可变变量状态变化可见。
  • 答:替代匿名对象的轻量方式?答:SAM 接口用 lambda;需要附加状态时保留对象表达式。

04.8.1.2-071 data class 的可变集合属性在相等性上有什么坑?

一句话结论

集合属性参与 equals/hashCode 时,集合内容变化会改变相等性与哈希;同一 data class 实例入集合前后内容被修改,会导致元素无法找回。

概念解释

相等性按属性值计算,集合属性的「值」取决于集合当前内容。可变集合被外部修改后,对象与最初放入集合时不再相等,Set/Map 分组失效。

原理流程

  1. 对象加入集合,按当前集合内容计算哈希。
  2. 外部修改集合元素。
  3. 后续查找按新内容计算哈希,原桶位不匹配。
  4. 业务去重、缓存判断出现不一致。

代码或图示

data class Cart(val items: MutableList<String>)
val cart = Cart(mutableListOf("a"))
val set = mutableSetOf(cart)
cart.items.add("b") // 哈希变化,set 中找不到原条目

常见误区

  • 公开内部可变集合引用:外部绕过方法改值。
  • 把需要动态变化的列表放进 data class 相等性字段。

追问

  • 答:安全做法是什么?答:属性暴露只读 List,修改通过封装方法并在集合外先移除旧对象。
  • 答:集合相等性按什么规则?答:按标准库集合 equals 内容比较,顺序型集合与无序集合规则不同。

04.8.1.2-072 data class 的可空属性如何 copy?

一句话结论

可空属性在 copy 时可传入新值、保留原值,也可显式传 null;未传参数沿用原实例值,copy 不要求所有属性非空。

概念解释

copy 参数类型与构造属性一致,可空属性接受 null。嵌套可空对象同理:覆盖时传入新可空值,不覆盖保留原引用。

原理流程

  1. 读取原实例各属性。
  2. 命名参数覆盖对应可空字段。
  3. 未传字段沿用原值,包括 null。
  4. 新实例按构造规则建立。

代码或图示

data class Profile(val nickname: String?, val avatar: String?)
val p = Profile("Ann", null)
val q = p.copy(avatar = null, nickname = "Anna")

常见误区

  • 以为 copy 会把可空属性重置为非空默认值:未传即沿用原值。
  • 覆盖嵌套可空对象时只改内层字段:需逐层 copy。

追问

  • 答:copy 能否把非空属性改为 null?答:不能,类型不允许;需要改类型声明。
  • 答:默认值属性 copy 行为?答:未传时沿用实例当前值,不是重新取默认值。

04.8.1.2-073 场景:如何用 sealed 建模 Result/Error 体系?

一句话结论

顶层 sealed 定义成功与失败分支,成功分支携带数据,失败分支携带错误类型与消息;when 穷尽处理,避免用可空返回加异常混合表达结果。

概念解释

Result 类型把「成功值」与「失败原因」纳入类型系统:调用方必须处理两个分支。错误层级可继续 sealed 细分领域错误、外部依赖错误等。

原理流程

  1. 声明 sealed Result<out T>。
  2. Success 携带值,Failure 携带错误。
  3. 业务函数返回 Result<T> 而非裸抛异常。
  4. 调用方 when 分派,穷尽覆盖成功与失败。

代码或图示

sealed class Result<out T>
data class Success<out T>(val value: T) : Result<T>()
data class Failure(val error: AppError) : Result<Nothing>()

fun load(): Result<User> = /* ... */

常见误区

  • 失败分支仍随意抛异常:结果类型被旁路。
  • 错误信息只存字符串:丢失错误码与可分类类型。

追问

  • 答:Failure 为什么是 Result<Nothing>?答:失败不承载成功值,Nothing 兼容协变位置。
  • 答:结果类型如何串联后续操作?答:map/flatMap 一类扩展在成功分支变换,失败分支透传。

04.8.1.2-074 场景:值对象选 value class 还是 data class?

一句话结论

单个基础值、需要编译期防混淆且可接受装箱边界用 value class;多字段、需要序列化/框架兼容或携带行为用 data class。

概念解释

value class 轻量但限制多:单值、序列化反射受限、泛型边界装箱。data class 字段自由、生成完整值语义,但每个实例有对象开销。

原理流程

  1. 统计值对象字段数量:单值优先评估 value class。
  2. 检查框架兼容:序列化、持久化、反射是否支持。
  3. 评估装箱场景:是否进入大集合/可空位置。
  4. 多字段或兼容要求高:选 data class。

代码或图示

@JvmInline value class Money(val amount: Long)
data class Address(val city: String, val street: String, val zip: String)

常见误区

  • 标识类用裸字符串:类型混淆风险进入调用层。
  • 简单单值也建 data class:无必要对象开销。

追问

  • 答:value class 能校验取值范围吗?答:可在 init 校验,但注意内联场景初始化时机。
  • 答:跨边界 DTO 用什么?答:普通 data class,进入领域层再包装为值对象。

04.8.1.2-075 场景:配置类如何用 data class 带默认值建模?

一句话结论

配置 data class 为每个可选项提供合理默认值,必填项非空;外部覆盖只传命名参数,合并默认值与外部配置后得到不可变配置实例。

概念解释

配置建模区分工程默认、环境覆盖与必填项。data class 默认值让构造简洁,不可变属性避免运行时被改;集合配置默认空集合而非 null。

原理流程

  1. 声明配置 data class,字段带默认值。
  2. 加载层合并外部配置与默认值。
  3. 必填字段缺失在校验期失败。
  4. 运行时读取只读配置实例。

代码或图示

data class ServerConfig(
    val host: String,
    val port: Int = 8080,
    val threads: Int = 16,
    val features: Set<String> = emptySet()
)

常见误区

  • 集合字段默认为 null:使用处反复判空。
  • 默认值散落在读取代码:集中在数据类声明。

追问

  • 答:配置热更新如何替换?答:生成新配置实例替换引用,旧实例不可变保留。
  • 答:敏感配置字段如何处理?答:不写入日志,序列化时单独脱敏。

04.8.1.2-076 场景:策略/工厂用 object 还是伴生对象?

一句话结论

无状态策略实现用 object 单例;属于某个类的工厂方法与类级常量放伴生对象。多策略注册表可用 object 持有策略映射。

概念解释

object 是全局单例,适合无状态可复用组件;伴生对象绑定特定类,组织该类的构造与类级逻辑。两者都在类加载/首次访问时初始化。

原理流程

  1. 判断组件是否绑定特定类:绑定关系放伴生对象。
  2. 独立无状态策略用 object 实现接口。
  3. 多策略按名称注册到 object 注册表。
  4. 调用方通过对象名或伴生成员获取实例。

代码或图示

interface Parser { fun parse(raw: String): Item }
object JsonParser : Parser { override fun parse(raw: String) = /* ... */ }

class Product private constructor(...) {
    companion object {
        fun from(raw: String): Product = /* ... */
    }
}

常见误区

  • 把实例相关状态放进 object:被所有调用方共享。
  • 工厂方法散落在顶层函数:与类归属关系不清。

追问

  • 答:策略需要配置参数怎么办?答:object 提供无状态逻辑,参数由调用方传入;有状态策略用普通类实例。
  • 答:伴生对象能否实现接口?答:可以,常用于工厂与契约约束。

04.8.1.2-077 场景:回调接口用匿名 object 还是 lambda?

一句话结论

Java/Kotlin 单抽象方法接口优先用 lambda,简洁且无显式对象;接口含多个方法或需要附加状态、保存引用时用匿名 object 表达式。

概念解释

SAM 转换让 lambda 直接适配函数式接口。匿名对象可实现多个方法、捕获局部状态、被后续反注册;lambda 引用也可保存为函数类型变量。

原理流程

  1. 检查接口方法数量:单方法优先 lambda。
  2. 需要多方法或状态:对象表达式。
  3. lambda 赋值给函数类型变量后可反注册。
  4. 回调中注意捕获引用生命周期。

代码或图示

button.setOnClickListener { println("clicked") }

val callback = object : ResultListener {
    override fun onSuccess() {}
    override fun onFailure(e: Throwable) {}
}

常见误区

  • 多方法接口硬写 lambda:语法不支持,需对象表达式。
  • 回调对象持有页面级引用却不反注册:泄漏。

追问

  • 答:Kotlin 自身接口能否 SAM 转换?答:Kotlin 函数类型优先;Kotlin 声明接口的 SAM 支持范围以编译器版本为准(待确认)。
  • 答:lambda 与对象表达式捕获规则相同吗?答:都按闭包规则持有外层变量引用。

04.8.1.2-078 性能:data class 生成代码对方法数与字节码体积有什么影响?

一句话结论

每个 data class 生成 equals、hashCode、toString、copy、componentN 等方法,类与数量增多时方法数与字节码增长;值语义收益需与体积成本权衡。

概念解释

生成成员以构造属性为基础,属性越多方法体越长。大量细粒度 data class 会增加方法计数;热点对象实例化与拷贝成本需实测,而非只看源码简洁度。

原理流程

  1. 编译器为类生成固定数量成员方法。
  2. 方法体遍历构造属性拼接比较、哈希、字符串。
  3. 属性规模决定单个方法字节码长度。
  4. 方法数随类数量线性累积。

代码或图示

data class Metric(val name: String, val value: Double, val tag: String?)
// 编译产物包含上述生成成员,方法数量与属性遍历成本可在构建产物中查看

常见误区

  • 忽略 Android 方法数限制场景:超大型工程需审查细粒度值对象数量。
  • 只看源码行数判断性能:生成方法体才是字节码成本主体。

追问

  • 答:哪些生成成员可手写替代?答:相等性、字符串表示可覆盖;copy/解构按需要保留。
  • 答:实测手段有哪些?答:查看构建产物方法数、字节码大小与实例分配热点。

04.8.1.2-079 性能:value class 装箱消除的条件是什么?

一句话结论

在非空局部变量、非空参数与返回值等直接使用点,value class 可内联为底层类型;进入可空位置、泛型容器、跨类型边界或反射场景时退化为装箱对象。

概念解释

内联消除依赖编译器证明包装只作为底层值使用。擦除与空值要求对象表示,是装箱的主要触发条件。性能敏感代码应减少包装对象进入大集合。

原理流程

  1. 使用点满足直接值表示:内联展开为底层类型。
  2. 类型可空:需要包装对象承载 null。
  3. 泛型实参:擦除要求引用类型。
  4. 跨语言/反射边界:按对象表示处理。

代码或图示

value class UserId(val value: Long)
fun direct(id: UserId) = id.value        // 倾向内联
fun boxed(list: List<UserId>) = list.size // 元素装箱

常见误区

  • 以为 value class 全局零开销:边界装箱不可避免。
  • 高频创建临时包装对象进集合:分配压力需实测。

追问

  • 答:如何验证是否装箱?答:查看字节码签名与对象分配热点,结合反编译产物判断。
  • 答:无符号/原始大数组能否替代?答:按场景评估,原始类型数组连续存储无包装对象。

04.8.1.2-080 性能与资源:object 单例持有外部资源有什么释放问题?

一句话结论

单例生命周期等于应用进程,持有短生命周期资源(页面、请求连接、文件句柄)会导致资源无法释放;单例应只保存长生命周期共享状态。

概念解释

object 实例不随页面或请求销毁,引用被长期持有。资源型成员需要显式关闭、清空或改为注入式实例,避免内存与句柄泄漏。

原理流程

  1. 单例创建后实例长期存活。
  2. 注入的外部资源被成员引用保留。
  3. 资源本应在作用域结束时释放,被单例延长生命周期。
  4. 累积后出现内存、连接或文件句柄泄漏。

代码或图示

object SessionCache {
    private val holders = mutableMapOf<String, Any>()
    fun clear() = holders.clear() // 作用域结束时主动清理
}

常见误区

  • 在单例中缓存 Activity、Context 等页面对象。
  • 只清数据不清引用类型:泄漏对象仍可达。

追问

  • 答:需要按作用域持有资源怎么做?答:改为普通类实例,由作用域容器管理生命周期。
  • 答:单例状态并发读写如何保护?答:按需使用同步方法或并发集合,不能依赖初始化安全。

04.8.1.2-081 坑:inner 类持有外部引用如何导致内存泄漏?

一句话结论

inner 类实例保存外部实例引用,当内部类被长生命周期结构持有时,外部实例连同其成员都无法回收,形成泄漏链。

概念解释

匿名内部类、回调、监听器是典型场景:订阅总线持有内部类实例,内部类再持有外部页面对象。外部页面应销毁时仍被引用链可达。

原理流程

  1. 创建 inner 实例,捕获外部 this。
  2. 长生命周期容器订阅/持有内部类。
  3. 引用链:容器 → 内部类 → 外部实例。
  4. 外部实例本应回收,但仍可达,泄漏。

代码或图示

class Screen {
    private val handler = object : Callback {
        override fun onEvent() = render()
    }
    fun attach() = bus.subscribe(handler)
    fun detach() = bus.unsubscribe(handler) // 必须反注册
}

常见误区

  • 只在创建处传回调,忘记反注册。
  • 静态/嵌套类无法满足外部访问时,用弱引用或显式清理替代。

追问

  • 答:如何判断泄漏?答:内存分析看外部实例是否被回调/总线引用链持有。
  • 答:嵌套类与 inner 类哪个安全?答:嵌套类不持有外部引用,无此类泄漏;需要外部成员才用 inner。

04.8.1.2-082 坑:委托属性每次取值的开销是什么?

一句话结论

委托属性每次读写都经过委托对象的 getValue/setValue 转发,存在方法调用与状态访问开销;lazy 类委托还包含首次计算与后续缓存读取。

概念解释

委托把属性逻辑外置,访问不再是直接字段读取。简单委托开销小,复杂委托(同步、观察、缓存)在高频访问路径上累积成本。

原理流程

  1. 读取属性:编译器调用委托 getValue。
  2. 委托内部读取缓存、计算或通知。
  3. 写入属性:调用 setValue 并执行观察逻辑。
  4. 高频路径上转发与内部逻辑叠加产生开销。

代码或图示

var name by Delegates.observable("") { _, old, new -> log(old, new) }
// 每次 set 都触发回调;每次 get 都经过委托转发

常见误区

  • 热循环里频繁访问委托属性:忽略转发开销。
  • 委托内部持有大对象却随属性生命周期存活。

追问

  • 答:lazy 首次与后续访问成本?答:首次执行计算 lambda,后续读缓存字段;线程安全模式影响同步成本。
  • 答:如何优化高频访问?答:读入局部变量复用,或热点属性改为直接字段。

04.8.1.2-083 坑:伴生对象在类加载期初始化有哪些注意点?

一句话结论

伴生对象随类加载/首次访问初始化,其属性与工厂逻辑在此时建立;重初始化逻辑、外部依赖缺失会影响类加载,且状态被所有实例共享。

概念解释

伴生对象不是普通实例,类级状态全局唯一。初始化顺序、静态依赖循环与异常都会影响类可用性;把可变业务状态放伴生对象等于全局共享。

原理流程

  1. 类被首次引用触发类加载。
  2. 伴生对象字段初始化与对象体执行。
  3. 初始化失败按 JVM 类加载错误规则表现。
  4. 后续所有实例共享伴生对象状态。

代码或图示

class TokenService {
    companion object {
        private var cache: Map<String, String> = emptyMap()
    }
}

常见误区

  • 伴生对象里放请求级可变状态:跨请求污染。
  • 初始化依赖远程资源:类加载期阻塞或失败。

追问

  • 答:伴生对象与顶层单例对象区别?答:伴生对象绑定类访问入口,对象声明为独立全局单例。
  • 答:类加载初始化异常如何排查?答:查看类初始化堆栈与伴生对象静态字段初始化顺序。

04.8.1.2-084 坑:data class 继承普通类时 equals 不对称如何表现?

一句话结论

子类加入附加字段后,父类实例与子类实例互相比较路径不同,可能 a == b 为真而 b == a 为假;集合与缓存场景下相等性判断不稳定。

概念解释

相等性契约要求对称。父类 equals 不了解子类字段,子类比较又纳入自身状态,双向调用产生不同结论。值类型层级应避免开放继承。

原理流程

  1. 父类实现或继承默认相等性。
  2. 子类 data class 生成纳入自身字段的比较。
  3. 父类 equals 比较子类实例时未看附加字段。
  4. 双向比较结果不一致,违反对称契约。

代码或图示

open class Base(val sku: String)
data class SkuItem(val sku: String, val name: String) : Base(sku)
// 双向 equals 一致性需补测试;父类实现未考虑子类字段时存在风险

常见误区

  • 只断言单向相等:漏掉对称性问题。
  • 为图方便让值对象继承开放业务类。

追问

  • 答:如何修复?答:值对象用组合替代继承,或在父类统一实现包含层级字段的相等性并测试双向断言。
  • 答:sealed 层级能缓解吗?答:子类集合封闭,相等性设计可整体审查,但仍需实现正确。

04.8.1.2-085 坑:sealed 跨模块子类扩展有什么限制?

一句话结论

sealed 层级封闭在编译器认可的模块/包范围内,外部模块不能新增子类;需要跨模块扩展时应改用开放抽象类/接口,或调整模块划分。

概念解释

封闭性保证 when 穷尽检查成立。跨模块硬加子类会破坏层级封闭,编译报错。设计时需区分「有限取值」与「预留扩展」两类需求。

原理流程

  1. 编译器记录 sealed 允许的子类位置范围。
  2. 外部模块声明子类被规则拒绝。
  3. when 穷尽性依赖子类集合完整。
  4. 需要开放扩展:使用普通 abstract class/interface。

代码或图示

// module-a:
sealed class Command
// module-b 中声明 : Command 子类会受封闭规则限制

常见误区

  • 把预留三方扩展的类型设计成 sealed。
  • 版本升级后放宽位置规则:以目标版本编译器实测为准(待确认)。

追问

  • 答:同模块不同包是否允许?答:按编译器版本规则,需在工程中验证报错边界。
  • 答:开放扩展与穷尽检查如何取舍?答:开放层级失去编译期穷尽,调用方需 else 兜底。

04.8.1.2-086 与 Java 对比:构造器一次声明属性相比 Java POJO 省了哪些样板?

一句话结论

Java POJO 需要写字段、构造器赋值、getter/setter;Kotlin 主构造参数带 val/var 一步生成属性与访问器,data class 再补值语义成员。

概念解释

样板减少来自语法融合:参数即属性,访问器默认生成。对比时注意 Kotlin 仍在字节码生成对应字段与方法,只是源码不重复书写。

原理流程

  1. Java:声明字段 → 构造器赋值 → getter/setter。
  2. Kotlin:构造参数声明属性,编译器生成幕后字段与访问器。
  3. data class 额外生成相等性、复制、解构。
  4. 外部调用方式与 Java Bean 约定基本兼容。

代码或图示

// Kotlin 一行等价 Java 字段 + 构造赋值 + getter/setter
class User(val name: String, var age: Int)

常见误区

  • 以为 Kotlin 不生成字段:字节码仍有幕后字段,只是源码省略。
  • 把所有属性都写成可变:与不可变建模原则冲突。

追问

  • 答:Java 框架按 getter/setter 访问 Kotlin 属性可以吗?答:按生成访问器命名约定匹配,具体框架需验证。
  • 答:只读属性在 Java 侧有 setter 吗?答:val 只生成 getter。

04.8.1.2-087 与 Java 对比:data class 替代 Lombok 的边界是什么?

一句话结论

data class 在语言层固定生成相等性、toString、copy、解构;Lombok 在编译期按注解生成 getter/setter/构造器等,可配置范围更宽,但依赖注解处理。

概念解释

data class 面向值对象契约,生成成员围绕构造属性;Lombok 服务于 Java Bean 习惯,可灵活选择字段与方法。迁移时需确认框架对 Kotlin 构造器与访问器的兼容。

原理流程

  1. Lombok 注解处理在编译期改写字节码。
  2. data class 由 Kotlin 编译器直接生成成员。
  3. 相等性/复制/解构是 data class 特有能力。
  4. Java 侧需要无参构造或 setter 时,data class 需额外配置。

代码或图示

data class Order(val id: Long, val amount: BigDecimal)
// 对比 Java + Lombok:@Getter/@Setter/@RequiredArgsConstructor 等注解组合

常见误区

  • 期待 data class 提供 Java Bean 全量 setter:只读 val 不生成 setter。
  • 忽略注解处理工具链差异:Kotlin 编译与 Lombok 处理顺序可能不同。

追问

  • 答:序列化框架兼容哪个更稳?答:按所用框架实测 Kotlin 构造器重建能力,不以经验下结论。
  • 答:data class 能否手写 getter/setter?答:可以覆盖生成访问器,自定义逻辑优先。

04.8.1.2-088 与 Java 对比:sealed 如何替代 Java sealed class 与枚举组合?

一句话结论

Java 17+ sealed class 限制子类并配合模式匹配;Kotlin sealed 更早进入语言体系,支持 sealed interface、data object 等组合,when 穷尽检查在编译期完成。

概念解释

两侧都表达有限层级,Kotlin 在接口封闭、带载荷分支与穷尽分派上表达更紧凑。Java 枚举仍是固定单例常量,Kotlin sealed 子类可携带不同数据结构。

原理流程

  1. Java sealed:类/接口 permits 子类,模式匹配在运行时或预览特性中演进。
  2. Kotlin sealed:编译器封闭子类集合,when 编译期穷尽。
  3. 带数据分支用 data class,单例标记用 object/data object。
  4. 跨语言签名按各自字节码规则呈现。

代码或图示

sealed interface Shape
data class Circle(val r: Double) : Shape
data class Rect(val w: Double, val h: Double) : Shape

常见误区

  • 把 Java sealed 能力逐条对应到旧 Kotlin 版本:语法与规则有版本差异。
  • sealed 与枚举职责混用:按是否携带数据选型。

追问

  • 答:Java record 与 Kotlin data class 对应什么?答:都是不可变值类型载体,生成相等性与构造逻辑;互操作兼容需实测。
  • 答:版本不确定如何标注?答:写明待确认的语法点与编译验证步骤。

04.8.1.2-089 与 Java 对比:静态成员组织方式有什么差异?

一句话结论

Java 用 static 字段/方法挂在类上;Kotlin 无 static 关键字,类级逻辑放伴生对象或顶层声明,互操作时用 @JvmStatic/@JvmField 生成静态签名。

概念解释

Kotlin 源码层用对象组织类级成员,字节码形态由注解决定。顶层函数/属性编译到文件包装类;伴生对象默认是实例成员,需要注解才暴露静态调用。

原理流程

  1. Java:static 成员直接属于类。
  2. Kotlin 伴生对象:绑定类的单例对象。
  3. 顶层成员:文件包装类静态形态。
  4. 注解控制 Java 侧调用签名。

代码或图示

class Config {
    companion object {
        @JvmStatic const val NAME = "app"
    }
}

常见误区

  • 以为伴生成员字节码天然静态:默认是对象实例成员。
  • 顶层函数在 Java 侧按类名直接猜调用:需查看生成包装类名。

追问

  • 答:const val 与 @JvmStatic 区别?答:常量编译期内联;@JvmStatic 生成静态方法转发。
  • 答:Kotlin 静态工厂写在哪里?答:伴生对象方法,必要时加 @JvmStatic 兼容 Java。

04.8.1.2-090 Kotlin 2.x 中 value class 的稳定状态有哪些需要确认?

一句话结论

value class 作为内联类的稳定形态已进入标准语言体系,但具体注解要求、泛型/可空装箱规则、与序列化库的兼容程度必须在项目编译版本上实测确认。

概念解释

语言版本演进中,inline class 历史名称与 value class 命名有调整;不同编译器版本对边界规则、警告诊断可能不同。面试与文档中不应编造固定版本号。

原理流程

  1. 记录项目 Kotlin 版本与标准库版本。
  2. 查官方文档 value class 章节的稳定状态标注。
  3. 最小工程验证内联、装箱、序列化与反射表现。
  4. 不确定结论标注「待确认」并写明验证步骤。

代码或图示

// 待确认:当前版本 value class 注解要求与边界装箱表现
// 验证点:编译工程查看字节码签名、泛型容器装箱行为、序列化正反结果

常见误区

  • 把博客或旧文档中的 inline class 规则当作 2.x 确定行为。
  • 忽略标准库版本与编译器版本分别演进。

追问

  • 答:官方文档入口在哪里?答:kotlinlang.org 文档的 Value classes 章节。
  • 答:待确认清单应包含什么?答:版本号、编译命令、观察到的签名与行为。

04.8.1.2-091 面试手写:写一个不可变 data class 并解释生成成员

一句话结论

手写含若干 val 属性的 data class,能说清生成的 equals/hashCode、toString、copy、componentN 依据构造属性工作,且实例不可变。

概念解释

评分点:属性全 val、集合只读、解释各生成成员的输入来源与用途、指出类体属性不参与生成契约。

原理流程

  1. 声明 data class 与构造属性。
  2. 说明相等性基于构造属性值。
  3. 说明 copy 生成新实例、componentN 解构顺序。
  4. 指出可变集合与类体属性的注意点。

代码或图示

data class Article(
    val id: Long,
    val title: String,
    val tags: List<String> = emptyList()
)

常见误区

  • 把核心字段写成类体属性:生成成员不纳入。
  • 解释时遗漏 copy 与解构的生成来源。

追问

  • 答:两个 Article 何时相等?答:id、title、tags 内容全部相等。
  • 答:tags 被外部修改会怎样?答:只读视图下外部不能改;若暴露 MutableList 则相等性受影响。

04.8.1.2-092 面试手写:用 sealed 表达树结构

一句话结论

顶层 sealed 表示节点,叶子节点携带值,内部节点携带左右子树;递归结构配合 when 穷尽求值,体现 ADT 与递归类型建模。

概念解释

树是递归 ADT:叶子与内部节点两种分支。sealed 封闭层级保证 when 覆盖全部节点类型,求值函数递归处理子节点。

原理流程

  1. 声明 sealed Expr。
  2. Num 叶子携带数值,Sum 内部节点持有两个子树。
  3. 求值函数 when 分派,内部节点递归。
  4. 新增节点类型时编译期提醒补充分支。

代码或图示

sealed class Expr
data class Num(val n: Int) : Expr()
data class Sum(val left: Expr, val right: Expr) : Expr()

fun eval(e: Expr): Int = when (e) {
    is Num -> e.n
    is Sum -> eval(e.left) + eval(e.right)
}

常见误区

  • 内部节点忘记递归:只处理一层结构。
  • when 留无意义 else:封闭层级失去穷尽检查价值。

追问

  • 答:如何扩展乘法节点?答:新增 sealed 子类,编译器提醒更新 when。
  • 答:树节点需要附加元数据怎么办?答:在对应 data class 增加字段。

04.8.1.2-093 面试手写:解释一段继承/重写编译报错

一句话结论

按「父类是否 open → 被重写成员是否 open → 子类是否标 override → 签名与可见性是否兼容」定位报错,给出对应修复。

概念解释

常见报错:父类未 open、成员未 open、重写缺 override、可见性收紧、类型不兼容。答题先复述诊断含义,再给修复并说明语义。

原理流程

  1. 检查类继承是否允许:父类需 open/抽象/接口。
  2. 检查成员是否可重写。
  3. 子类方法标注 override。
  4. 核对参数、返回类型与可见性兼容。

代码或图示

// 报错:父类 final 不可继承 / 成员未 open / 缺少 override
open class Base { open fun act() {} }
class Derived : Base() { override fun act() {} }

常见误区

  • 直接给父类全加 open:未评估扩展设计边界。
  • 忽略可见性规则:子类不能更不可见。

追问

  • 答:方法签名相同却不标 override 会怎样?答:被视为新方法,父类方法未被覆盖,多态失效。
  • 答:属性重写报错如何排查?答:检查可变性与类型协变边界。

04.8.1.2-094 面试手写:自定义委托属性实现非空校验

一句话结论

实现只读/读写委托,在 getValue/setValue 中校验值非空,非法值抛异常;属性声明 by 委托实例,约定方法加 operator。

概念解释

评分点:委托约定签名、非空判断、异常类型、operator 修饰,以及只读属性只实现 getValue。可结合 ReadWriteProperty 标准接口。

原理流程

  1. 定义委托类持有内部状态。
  2. 实现 getValue 返回校验后的值。
  3. 可变委托实现 setValue,写入前校验。
  4. 属性委托声明接入。

代码或图示

class RequiredString : ReadWriteProperty<Any?, String> {
    private var value: String = ""
    override fun getValue(thisRef: Any?, property: KProperty<*>) = value
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        require(value.isNotBlank()) { "${property.name} 不能为空" }
        this.value = value
    }
}

var username: String by RequiredString()

常见误区

  • 漏掉 operator/接口约定:委托不生效。
  • 校验放在 get 而非 set:非法值已写入状态。

追问

  • 答:委托如何拿到属性名?答:通过 KProperty 参数访问 name 与注解。
  • 答:只读委托实现哪个接口?答:ReadOnlyProperty,仅 getValue。

04.8.1.2-095 面试手写:区分嵌套类与 inner 类的反编译形态

一句话结论

嵌套类编译为独立静态类,无外部实例字段;inner 类保存外部实例引用字段,构造器接收外部对象。默写两种声明并指出引用持有差异。

概念解释

评分点:默认嵌套类不持有外部引用,inner 持有外部 this;互操作构造签名、内存泄漏风险与访问外部成员权限。

原理流程

  1. 写普通嵌套类:静态类,成员不可访问外部实例状态。
  2. 写 inner 类:构造绑定外部实例,可访问外部成员。
  3. 对比字节码字段:inner 有外部引用字段。
  4. 说明长生命周期持有的泄漏风险。

代码或图示

class Outer {
    private val secret = 1
    class Nested { /* 无 Outer 引用 */ }
    inner class Inner { fun read() = secret }
}

常见误区

  • 把嵌套类描述为持有外部引用。
  • 忽略 inner 构造需要外部实例前提。

追问

  • 答:inner 类如何显式引用外部 this?答:this@Outer。
  • 答:哪种类适合做回调避免泄漏?答:不持有外部引用的嵌套类/顶层类,配合弱引用或反注册。

04.8.1.2-096 局部类有哪些规则与限制?

一句话结论

类可声明在函数内部,仅在该作用域可见,可捕获外层局部变量;局部类不能有可见性修饰符,名称不对外暴露,多用于一次性辅助实现。

概念解释

局部类类似局部函数,作用域限定在声明块内。它可访问外层捕获变量,但不能被外部引用类型声明。匿名对象表达式是局部类的匿名形式。

原理流程

  1. 函数体内声明 class Local { ... }。
  2. 编译器生成作用域受限的类。
  3. 捕获外层局部变量按闭包规则持有。
  4. 函数返回后局部类类型不可被外部命名使用。

代码或图示

fun build(): List<String> {
    class Accumulator { val items = mutableListOf<String>() }
    val acc = Accumulator()
    return acc.items
}

常见误区

  • 给局部类加 private/public:可见性修饰不适用。
  • 函数返回局部类实例却暴露类型:外部只能按推断类型使用。

追问

  • 答:局部类与匿名对象表达式区别?答:局部类有名称可多次实例化;匿名对象一次性创建。
  • 答:局部类能声明伴生对象吗?答:受语言规则限制,具体以编译器版本为准(待确认)。

04.8.1.2-097 泛型约束下的继承与重写有哪些衔接点?

一句话结论

子类类型参数、父类泛型实参与重写方法签名需要兼容;型变规则决定集合/函数类型能否替换,本页只点到衔接,完整规则见泛型章节。

概念解释

继承引入泛型实参后,子类型关系受型变约束。重写方法返回类型可协变收窄,参数方向需兼容;泛型擦除后运行时只保留外层类型。

原理流程

  1. 子类声明父类时传入泛型实参。
  2. 检查实参与父类型变标注兼容。
  3. 重写方法签名沿子类型规则匹配。
  4. 擦除后泛型实参不保留到运行时。

代码或图示

open class Repository<T>
class UserRepository : Repository<User>()

常见误区

  • 忽略型变导致子类集合不能替换父类集合。
  • 运行时按泛型实参做类型判断:擦除受限。

追问

  • 答:out/in 型变详解见哪节?答:04.8.1.3 泛型、扩展、inline 与 DSL。
  • 答:重写方法协变返回如何体现?答:子类返回父类返回类型子类型。

04.8.1.2-098 构造器上的注解与默认属性如何配合使用?

一句话结论

注解可标注在构造参数、属性或 setter/getter 上,作用目标由注解声明的适用位置决定;默认值参数在注解处理与互操作签名中按规则呈现。

概念解释

Kotlin 区分构造参数、属性、访问器等注解目标。DI、序列化、校验框架常通过注解读取构造属性;注解位置错误会导致框架识别不到。

原理流程

  1. 注解定义适用目标(参数、属性、字段、访问器)。
  2. 构造参数加注解按目标传播。
  3. 默认值参与生成重载与签名。
  4. 框架反射按注解目标读取元数据。

代码或图示

data class ApiUser(
    @JsonProperty("id") val id: Long,
    val name: String = "guest"
)

常见误区

  • 注解加错目标:框架在属性/字段上读不到。
  • 依赖默认值生成 Java 重载却不加 @JvmOverloads。

追问

  • 答:如何指定注解目标?答:使用 @field:、@get:、@param: 一类限定,具体语法以官方文档为准。
  • 答:注解保留策略影响反射吗?答:运行时保留的注解才可在反射读取,按框架要求确认。

04.8.1.2-099 贫血模型在 Kotlin 中如何表达?

一句话结论

贫血对象只持有数据与访问器,行为放在服务/领域服务中;Kotlin 用 data class 承载状态,配合类委托或扩展函数补充只读逻辑,保持模型简单。

概念解释

分层架构中数据模型与业务服务分离。Kotlin 值类型适合做贫血载体:不可变属性、值语义、序列化友好;复杂规则应避免堆在数据类内部。

原理流程

  1. data class 声明字段与默认值。
  2. 业务规则放入服务类或扩展函数。
  3. 模型不依赖外部框架与服务。
  4. 需要行为聚合时再演进为富领域对象。

代码或图示

data class Order(val id: Long, val amount: BigDecimal, val paid: Boolean)

class OrderService {
    fun canRefund(order: Order) = order.paid && order.amount > BigDecimal.ZERO
}

常见误区

  • 把所有业务判断塞进 data class:模型变重且难测试。
  • 贫血模型中暴露可变内部状态:破坏封装。

追问

  • 答:富模型与贫血如何取舍?答:核心领域规则内聚到模型;跨实体流程放在应用服务。
  • 答:扩展函数能否替代服务方法?答:只读派生逻辑可用扩展;有依赖与副作用的逻辑放服务类。

04.8.1.2-100 本页知识如何串联支撑领域建模?

一句话结论

构造与属性建立对象状态,委托与对象组织复用,data/sealed/value class 分别承载值对象、封闭分支与类型安全标识,共同构成 Kotlin 领域模型基础。

概念解释

各机制分工明确:不可变 data class 存数据,sealed 表达有限状态,value class 标识区分,object/伴生组织工厂与单例。组合使用时遵循不可变、封装与穷尽检查原则。

原理流程

  1. 识别模型是值对象、状态分支还是标识类型。
  2. 选择对应 data/sealed/value class 载体。
  3. 用构造属性、委托与封装控制状态变化。
  4. 配合 when 穷尽处理与互操作注解落地工程。

代码或图示

@JvmInline value class OrderId(val value: Long)
data class Order(val id: OrderId, val amount: BigDecimal)
sealed class OrderState {
    data object Pending : OrderState()
    data class Paid(val paidAt: Long) : OrderState()
}

常见误区

  • 一种载体硬套所有建模需求:按数据形态选型。
  • 忽略互操作与序列化约束:模型在边界处返工。

追问

  • 答:本页哪些概念在集合/互操作章节继续?答:只读视图、Java 签名映射、平台类型与注解。
  • 答:哪些在泛型章节继续?答:型变、类型擦除、委托约定与 reified。

参考来源

待整理清单

  • [ ] 在项目 Kotlin 2.x 版本上核对 value class 注解要求与装箱边界表现
  • [ ] 核对 sealed interface、data object、entries 等 API 的版本可用性
  • [ ] 补充 data class 与目标序列化/ORM 框架的互操作实测记录
  • [ ] 整理委托属性、类委托在字节码层的转发示例与性能对比