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。
原理流程
- 编译器为类与成员应用默认可见性
public。 - 类默认
final,禁止被继承。 - 成员默认
final,禁止子类重写。 - 需要扩展点时在类或成员前加
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 才生成多个重载。
原理流程
- 类名后括号内声明构造参数与默认值。
- 调用方按位置或命名传参,缺省参数取默认值。
- 主构造参数可加
val/var直接成为属性。 - 初始化逻辑放入
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(...));委托完成后再执行次构造器自身逻辑。
概念解释
主构造器是初始化核心,次构造器提供备选构造入口。次构造器不能绕过主构造器初始化流程;当类没有主构造器时,次构造器互相委托。
原理流程
- 声明
constructor(参数) : this(主构造参数)。 - 先执行主构造器参数初始化与
init块。 - 再执行次构造器体内语句。
- 多层委托最终汇聚到主构造器。
代码或图示
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 块按顺序拼接为初始化流程。
原理流程
- 父类主构造参数与初始化先执行。
- 子类属性初始化器按顺序运行。
- 遇到
init块执行其中语句。 - 全部初始化完成后对象才可使用。
代码或图示
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 的参数在类体内可作为属性访问;纯参数只在初始化阶段可用。
原理流程
- 构造参数带
val/var:编译器生成属性声明。 - 生成幕后字段与默认访问器。
- 初始化期把构造值写入字段。
- 类体内与外部按属性规则访问。
代码或图示
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 中做校验、派生计算或惰性取值。默认实现读写幕后字段;自定义访问器决定字段是否存在。
原理流程
- 声明
val/var属性与类型。 - 默认生成幕后字段与访问器。
- 自定义 getter:每次访问计算返回值。
- 自定义 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 不可用。
原理流程
- 属性默认声明触发幕后字段生成。
- setter 内
field指向该字段,可读可写。 - 纯派生 getter 不产生字段,访问器内无
field。 - 字段对外部不可见,只能通过访问器间接读写。
代码或图示
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 保存可变状态,外部属性返回只读视图或派生值。与幕后字段不同,它是开发者显式写的一对属性。
原理流程
- 声明私有可变存储属性。
- 公开属性只读暴露状态或只读集合视图。
- 内部方法修改私有存储。
- 外部无法绕过公开访问器改写内部状态。
代码或图示
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 解决构造期拿不到值、之后由框架或生命周期回调注入的非空属性。基本类型有默认零值,不适用延后初始化;局部变量作用域短,可直接判空或委托。
原理流程
- 属性声明为
lateinit var,类型非空。 - 不提供构造初始值。
- 使用前由外部赋值。
- 访问时检查初始化状态,未赋值抛专用异常。
代码或图示
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 等常用委托;自定义委托实现约定运算符即可复用。
原理流程
- 声明
val/var x by delegate。 - 读取属性:编译器调用委托的
getValue(thisRef, property)。 - 写入
var属性:调用setValue(thisRef, property, value)。 - 委托对象持有状态、缓存或变更通知逻辑。
代码或图示
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 提供延后赋值的可空兜底,首次读取前必须赋值。
概念解释
三者覆盖常见属性模式:惰性初始化、属性变更观察、非空延后赋值。委托把样板逻辑标准化,业务属性只声明委托与初始策略。
原理流程
lazy:首次访问执行 lambda,结果缓存,后续复用。observable:每次 setter 调用先更新值,再触发回调。notNull:内部状态初始为空,赋值后读取;未赋值读取抛异常。- 委托按属性类型适配只读或可变属性。
代码或图示
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(属性元信息)。委托可据此区分不同属性、读取元数据或实现通用缓存逻辑。
原理流程
- 声明委托类,持有内部状态。
- 实现
operator fun getValue(thisRef: Any?, property: KProperty<*>): T。 - 可变委托补
operator fun setValue(...)。 - 属性声明
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 关键字,类级逻辑放在伴生对象中。伴生对象可实现接口、定义属性与方法,每个类最多一个伴生对象。
原理流程
- 类体内声明
companion object { ... }。 - 编译器为其生成绑定类的单例实例。
- 外部通过
类名.成员访问伴生对象方法与属性。 - 伴生对象在类加载/首次访问时初始化。
代码或图示
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 静态调用习惯。
原理流程
- 伴生对象方法编译为对象实例方法。
- 标注
@JvmStatic后,编译器同时生成静态转发方法。 - Java 侧既可走静态签名,也可访问伴生对象实例。
- 属性标注后生成静态 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 调用、反射与序列化问题。伴生对象本身是一个对象实例,其状态在类级别共享;静态注解决定对外签名是静态还是实例访问。
原理流程
- 编译器为类生成伴生对象实例字段。
- 伴生方法编译为实例方法,属性为实例字段/访问器。
@JvmStatic生成静态转发方法。@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 类加载机制保证静态初始化的线程安全,不需要手写双重检查锁。对象内部状态的并发读写仍需自行保护。
原理流程
- 编译器为
object生成单例类与持有实例的静态字段。 - 类加载时执行对象体初始化,构造唯一实例。
- 外部引用同一实例。
- 可变状态在多线程访问时需要同步或并发容器。
代码或图示
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 名称 { ... } 定义模块级单例。两者编译产物与生命周期不同。
原理流程
- 对象表达式在执行到该处时创建新实例。
- 可继承类/实现接口,覆盖成员。
- 捕获的外层变量按闭包规则持有。
- 对象声明在类加载时创建唯一实例,全局复用。
代码或图示
val listener = object : ClickListener {
override fun onClick() { println("clicked") }
}
object GlobalRegistry { /* 单例 */ }
常见误区
- 把匿名对象当单例复用:每次执行表达式都可能创建新实例。
- 匿名对象持有外层长生命周期引用:引发内存泄漏。
追问
- 答:对象表达式能省略父类型吗?答:可以,此时类型为匿名对象类型,成员仅在局部可见。
- 答:SAM 接口场景优先用 lambda 还是对象表达式?答:函数式接口优先 lambda;需要多方法或附加状态时用对象表达式。
04.8.1.2-018 对象声明实现接口或继承类有哪些边界?
一句话结论
object 可以继承类、实现接口,并覆盖其抽象成员;单例实例同时扮演该类型角色,但不能再被实例化出第二个对象。
概念解释
对象声明是类与对象的结合体:有唯一实例,也有类型层级。工厂策略、常量实现、回调单例常通过对象实现接口暴露。
原理流程
object Name : SuperClass, Interface { ... }声明继承关系。- 覆盖抽象成员与开放成员。
- 实例按对象声明规则唯一创建。
- 可作为父类型参数传递。
代码或图示
object ConsoleLogger : Logger {
override fun log(msg: String) = println(msg)
}
常见误区
- 期待对象声明带构造参数:对象无公开构造器,状态在对象体内部初始化。
- 多个对象实现同一接口却共享状态:各自实例独立持有状态。
追问
- 答:对象声明能否继承开放类并调用父类构造?答:可以,继承时按父类构造规则传参。
- 答:接口默认方法在对象中如何处理?答:直接继承使用,需要改行为时覆盖。
04.8.1.2-019 嵌套类与 inner 类有什么区别?
一句话结论
嵌套类默认是静态内部类,不持有外部实例引用;inner 类是非静态内部类,持有外部实例引用,可访问外部类成员。
概念解释
Kotlin 嵌套类对应 Java 静态嵌套类;inner 对应 Java 内部类(非静态)。是否持有外部引用决定了访问能力与内存占用,也是内存泄漏的常见来源。
原理流程
- 普通嵌套类编译为独立静态类,无外部引用。
inner类构造时绑定外部实例,保存外部引用。inner内可直接访问外部成员。- 外部实例生命周期长于内部类时需注意引用持有。
代码或图示
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 消歧。
原理流程
inner实例构造时捕获外部this。- 成员解析先查内部类,再沿外部实例查找。
- 同名歧义用
this@Outer.member指定外部。 - 外部私有成员对内部类可见。
代码或图示
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 或框架反序列化时:构造器签名包含外部实例依赖。理解引用持有有助于排查实例化失败与泄漏。
原理流程
- 嵌套类生成静态类,构造器无外部参数。
inner类构造器接收外部实例引用。- Java 调用按生成签名传入外部对象。
- 框架无外部实例时无法直接实例化内部类。
代码或图示
class Container {
inner class Item(val label: String)
}
// Java 侧:先拿 Container 实例,再按内部类构造规则创建 Item
常见误区
- 把内部类当作可独立序列化的值对象:持有外部引用,序列化边界复杂。
- 框架反射实例化
inner类失败:缺少外部实例依赖。
追问
- 答:需要独立构造的辅助类型应声明为什么?答:普通嵌套类或顶层类,不持有外部引用。
- 答:内部类引用外部实例对内存有何影响?答:外部实例被内部类间接持有,内部类存活期间外部不可回收。
04.8.1.2-022 继承为什么需要显式 open?
一句话结论
Kotlin 类与成员默认 final,防止未经设计的继承扩展;只有显式 open、abstract 或接口成员才能被继承与重写。
概念解释
这是对 Java 可随意继承的收紧:类作者明确哪些扩展点开放。继承是强耦合关系,默认封闭减少误用。重写方法必须加 override,且不能降低可见性。
原理流程
- 编译器检查父类是否
open/抽象/接口。 - 子类声明继承关系。
- 被重写成员必须在父类可重写。
- 子类方法标注
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 转换受限制。
原理流程
- 编译器匹配父类可重写成员。
- 检查参数类型与返回类型兼容。
- 检查可见性:子类方法不得更不可见。
- 标注
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」且需要共享实现与状态的层级;接口用于能力契约,支持多实现。抽象成员无实现,子类必须覆盖;接口默认成员可直接复用。
原理流程
- 抽象类声明抽象属性/方法,无具体实现。
- 具体子类覆盖全部抽象成员后才可实例化。
- 接口声明方法与默认实现。
- 类通过冒号列表继承类并实现多个接口。
代码或图示
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 的默认属性实现,但不能持有幕后字段与构造状态;方法可提供默认实现,类按需覆盖。
概念解释
接口保持行为契约定位:属性访问逻辑可默认给出,状态存储留给实现类。默认方法解决接口演进时的兼容问题,避免所有实现类被迫新增方法。
原理流程
- 接口属性无初始存储字段。
- 默认 getter 基于接口方法或常量计算。
- 默认方法提供通用实现。
- 实现类覆盖需要变化的成员。
代码或图示
interface Named {
val name: String
val upper: String get() = name.uppercase()
fun describe() = "[$name]"
}
常见误区
- 在接口里声明
var状态字段:接口不能存储可变状态。 - 依赖接口默认方法保存跨调用状态:状态应在实现类持有。
追问
- 答:接口属性能否有 setter?答:接口属性实现受规则限制,可变状态由实现类定义。
- 答:多接口同名默认方法冲突如何处理?答:实现类必须覆盖冲突成员并指定委托来源。
04.8.1.2-026 接口继承与多实现冲突如何处理?
一句话结论
类可实现多个接口,成员同名冲突时必须在类中覆盖,并通过 super<接口名>.成员 指定调用某一父接口实现;接口之间也可继承扩展。
概念解释
多接口带来菱形冲突风险。Kotlin 要求冲突成员由实现类裁决:提供自己的实现,并可选择复用某接口默认方法。接口继承可组合行为契约。
原理流程
- 类声明实现多个接口。
- 编译器检测同名同签名成员冲突。
- 实现类覆盖该成员消除歧义。
- 需要复用默认实现时用限定
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 先建立。子类在父类构造期间调用开放方法时,方法可能被子类覆盖,而子类字段尚未初始化,是经典构造期陷阱。
原理流程
- 分配对象内存,字段置默认值。
- 执行父类构造参数、属性初始化与
init。 - 执行子类属性初始化与
init。 - 构造完成,返回实例。
代码或图示
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 用于承载数据的不可变值对象。生成成员以主构造参数为准;类体中声明的属性不参与自动生成的相等性与解构。手写成员会覆盖对应生成实现。
原理流程
- 编译器识别
data修饰与主构造属性。 - 生成基于属性的
equals/hashCode。 - 生成含属性列表的
toString。 - 生成
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 可安全用于集合键与判等。参与比较的是构造属性值,可空属性按空安全规则比较。类层级与可变属性会影响契约稳定性。
原理流程
equals先判同引用,再比较类型与各构造属性。- 所有属性相等返回 true。
hashCode组合参与相等性的属性。- 放入 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 生成新对象。属性顺序与命名参数对应,可空与默认值按构造规则处理。
原理流程
- 读取原实例各构造属性。
- 命名参数覆盖对应属性。
- 调用构造器创建新实例。
- 原实例保持不变。
代码或图示
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 形式拆包。组件顺序与构造参数绑定,属于公开契约;重排参数需同步检查解构使用点。
原理流程
- 生成
componentN返回第 N 个构造属性。 - 解构声明按位置调用组件方法。
- 各变量类型按组件返回类型推断。
- 组件数量不符时编译报错。
代码或图示
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 脱敏。
原理流程
- 编译器生成拼接类名与属性键值的实现。
- 各属性值调用其字符串表示。
- 嵌套对象递归展开。
- 手写
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 有可比较的数据状态。构造参数可带默认值与可空类型;类体属性不进入自动生成的相等性、解构与复制。
原理流程
- 主构造至少一个参数。
- 参与生成成员的参数带属性声明。
- 默认值与可空性按普通构造规则处理。
- 编译器校验参数与生成成员一致性。
代码或图示
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)。子类加入额外属性后,父类实例与子类实例比较容易违反对称性。
原理流程
- 子类 data class 生成比较逻辑。
- 父类
equals未考虑子类附加状态。 - 双向比较路径不同导致结果不对称。
- 放入集合后相等性判断不稳定。
代码或图示
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 后改值会导致元素定位错误。
原理流程
- 可变属性参与相等性计算。
- 对象入集合后属性被修改。
- 哈希值变化,原桶位无法找回元素。
- 业务缓存与去重判断出现不一致。
代码或图示
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 的值语义让它适合作为集合元素,但可变属性会破坏这一前提。
原理流程
- 加入集合时计算哈希并按相等性查找位置。
- 查找元素时重新计算哈希并比较属性。
- 属性未变:定位与去重符合预期。
- 属性被修改:哈希变化,原集合条目可能无法找回。
代码或图示
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 深拷贝范围内,需要单独处理。
原理流程
- 外层对象
copy时传入新的内层对象。 - 内层对象先基于原值
copy覆盖目标字段。 - 逐层返回新实例。
- 未涉及的属性与嵌套对象沿用原引用。
代码或图示
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 构造集中在主构造器,互操作时可能需要默认值、注解辅助或专用序列化器。具体框架行为以目标库版本为准。
原理流程
- 编译器按构造参数生成构造器签名。
- 无默认值参数的构造器不提供无参形式。
- 框架通过构造器反射或字段注入重建对象。
- 序列化库按 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 兜底即可被判定穷尽。
原理流程
- 声明
sealed class,子类在同一模块/包内受限位置声明。 - 编译器记录完整子类集合。
when表达式按子类分支检查覆盖。- 缺分支时编译报错,强制处理所有情形。
代码或图示
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,类层级仍保持封闭。
原理流程
- 声明 sealed interface 标记契约。
- 实现类/ sealed class 在允许范围内实现接口。
- 编译器封闭实现集合。
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 的核心价值:编译器枚举子类集合。位置规则随语言版本演进,新版放宽了部分同模块约束;跨模块继承默认不允许,除非使用开放替代方案。
原理流程
- 编译器校验子类声明位置是否在允许范围。
- 子类继承 sealed 父类型。
- 记录子类到封闭层级表。
- 位置越界或外部扩展时编译报错。
代码或图示
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 检查;子类为单例对象时可直接匹配对象类型。
原理流程
- 编译器取得 sealed 层级全部子类。
- 扫描
when分支覆盖的类型。 - 未覆盖子类列入诊断。
- 表达式形式要求穷尽,语句形式可保留兜底。
代码或图示
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 穷尽检查,选型看取值是否需要携带数据。
原理流程
- 判断候选取值是否需要附加状态:不需要用枚举。
- 不同取值携带不同字段/结构:用 sealed 层级。
- 枚举常量为单例,sealed 子类可实例化多个对象。
- 两者都配合
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 定义分支载荷,编译器保证分支完整处理。
原理流程
- 顶层 sealed 描述所有可能情形。
- 各子类定义自身字段结构。
- 业务代码用
when按分支处理。 - 新增情形时编译期强制更新处理逻辑。
代码或图示
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 为无状态分支提供规范的字符串表示与相等性;具体可用形式以编译器版本为准。
原理流程
- 需要携带字段:声明 data class 子类。
- 无状态标记:声明 object 或 data object。
- 需要自定义行为与状态:普通 class 子类。
- 编译器统一纳入封闭层级表。
代码或图示
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」这类类型混淆问题。
原理流程
- 声明
value class X(val value: 基础类型)。 - 满足内联条件时,编译产物直接使用底层类型。
- 不满足条件(可空、泛型实参等)时退化为装箱表示。
- 运行时按包装类型做编译期区分,按底层类型存储。
代码或图示
@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 在源码层是独立类型,字节码层按内联/装箱两种形态出现;边界处类型可能被抹平。
原理流程
- 编译器判断使用点是否满足内联条件。
- 满足:方法签名与局部变量使用底层类型。
- 不满足:生成包装类实例。
- 跨语言调用按生成签名呈现,包装语义不强制保留到 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 与编译器共同拦截误传。
原理流程
- 为每种标识声明独立 value class。
- 函数签名使用包装类型而非裸基础类型。
- 编译器检查实参类型匹配。
- 内部业务方法通过
.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 按包装值做值相等性比较;内联场景下对象身份被消除,=== 身份比较语义受限,业务判等应使用 ==。
概念解释
值语义意味着两个包装相同底层值的实例相等。内联消除后不存在稳定包装对象身份,反射、哈希、集合行为需按值类型理解。
原理流程
==比较底层值是否相等。- 内联表示下包装对象不固定存在。
===身份比较不适合作为业务判断依据。- 集合哈希按值类型规则计算。
代码或图示
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,包装对象随元素创建。
原理流程
- 声明
List<UserId>等泛型使用点。 - 擦除约束要求元素为引用类型。
- 编译器为 value class 生成装箱实例。
- 遍历与访问按包装对象进行。
代码或图示
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 侧表示可能是底层类型,反射拿到的类型信息受限;不同序列化库支持程度不同,必须在目标版本实测。
原理流程
- 序列化库读取对象类型与构造器。
- 内联点只暴露底层类型,包装元数据可能缺失。
- 重建时需要库识别 value class 约定。
- 不支持时改为普通包装类或专用 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;别名不产生独立类型,值类在满足条件时消除装箱。
概念解释
两者都基于单一基础类型,但安全强度不同:别名完全等价原类型,值类是独立类型。选型看是否需要阻止不同业务值互相赋值。
原理流程
- 评估是否需要类型混淆防护:不需要用别名。
- 需要防护:选 value class,评估装箱与序列化限制。
- 别名在编译期名称替换。
- 值类参与独立类型检查与值语义。
代码或图示
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(具体可用性以版本为准,待确认)。
原理流程
- 枚举声明参数与成员。
- 常量列表由编译器固定生成。
entries/values遍历全部常量。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 枚举常量的匿名类体如何使用?
一句话结论
枚举常量可声明匿名类体覆盖枚举方法,为每个常量提供不同实现;常量体在分号后书写,适合同一行为的不同分支实现。
概念解释
枚举不仅是标记,也可携带多态行为。各常量覆盖方法形成策略表;公共逻辑留在枚举基类,差异实现放入匿名体。
原理流程
- 枚举声明开放或抽象方法。
- 常量后接
{ ... }类体覆盖方法。 - 每个常量绑定自身实现。
- 调用方通过枚举类型多态分派。
代码或图示
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 只做类型/常量分派。
原理流程
- 编译器取得枚举全部常量。
- 扫描
when分支匹配的常量。 - 未覆盖常量列入诊断。
- 表达式形式要求穷尽后才可作为值使用。
代码或图示
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 子类为枚举受语言规则限制。
原理流程
- 定义 sealed interface 作为顶层标记。
- 无数据枚举常量实现该接口。
- 带数据分支用 data class 实现接口。
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 场景在运行时暴露异常。
原理流程
- 对象内存分配,字段取默认值。
- 按类体顺序执行属性初始化器与
init。 - 提前访问未赋值属性:读到默认值或抛异常。
- 构造完成后属性才可安全使用。
代码或图示
class Demo {
val a: Int = compute()
val b: Int = a + 1
}
常见误区
init中引用后面才初始化的属性:读到零值。- 父类开放方法在构造期被子类覆盖:子类属性尚未初始化。
追问
- 答:
lateinit未初始化访问异常类型?答:UninitializedPropertyAccessException。 - 答:如何排查构造期读到默认值?答:检查属性书写顺序与
init引用位置,必要时延后初始化。
04.8.1.2-058 构造器注入与字段注入在 Kotlin 中如何写?
一句话结论
构造器注入把依赖作为主构造参数,编译期保证依赖就绪;字段注入通过 lateinit 属性配合框架反射赋值,依赖在构造后由容器填充。
概念解释
构造注入利于不可变与测试,依赖在对象创建时确定;字段注入解耦构造与容器,但属性可空/延后初始化,需处理未就绪状态。Spring、Koin 等框架两种方式都支持。
原理流程
- 构造注入:依赖写入主构造参数或属性。
- 对象创建时依赖已传入。
- 字段注入:声明
lateinit可空属性,容器反射赋值。 - 使用前确认依赖已注入,避免未初始化访问。
代码或图示
// 构造注入
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。
原理流程
- 声明只读属性,避免
var状态。 - 内部可变集合通过只读属性暴露。
- 修改通过返回新实例(
copy)完成。 - 相等性与哈希基于不可变字段。
代码或图示
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 包私有混淆。可见性在编译期检查。
原理流程
- 声明位置确定可用边界集合。
- 引用点检查是否在允许边界内。
- 子类不能放宽父类成员可见性。
- 跨模块源码引用
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,子类覆盖访问逻辑。属性类型与可变性必须兼容父类声明。
原理流程
- 父类属性声明
open。 - 子类用
override声明同名属性。 - 覆盖 getter/setter 实现。
- 运行时按实例类型分派访问器。
代码或图示
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 时,两个方向都要满足。
原理流程
- 编译器比较父类与子类属性类型。
- getter 返回类型支持协变:子类型可用。
- setter 参数方向要求兼容父类写入约定。
- 不兼容类型重写编译报错。
代码或图示
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/存储实现;抽象属性不能有幕后字段初始值。
概念解释
抽象属性把「子类必须提供该状态/派生值」写成契约。父类可在方法中使用抽象属性,具体实现由子类补全。
原理流程
- 父类用
abstract val/var声明属性,无初始值。 - 子类用
override覆盖并提供实现。 - 未覆盖的子类仍是抽象类。
- 抽象属性访问器在父类方法中按多态分派。
代码或图示
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 调用方需要直接访问类或伴生实例,扩展方法需以工具函数形式暴露。
原理流程
- 声明伴生对象或类的扩展函数。
- Kotlin 源码内按扩展语法调用。
- 编译为静态工具方法形态。
- 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。
原理流程
- 类声明实现接口并指定委托对象。
- 编译器为接口每个方法生成转发方法。
- 委托对象缺失的成员由类自身覆盖补充。
- 属性委托则在读写点转发到
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 类委托如何体现「组合优于继承」?
一句话结论
类委托把复用逻辑放入被委托对象,外层类只增强少量行为,避免继承层级膨胀与父类实现细节耦合;需要多个能力时可委托多个对象。
概念解释
继承强耦合父类内部实现,委托通过接口持有组件。外层类保留自身状态与扩展点,被委托对象提供通用行为,替换实现不影响外层类型。
原理流程
- 识别可复用行为对应的接口。
- 用具体对象实现接口并作为委托组件。
- 外层类声明接口并
by委托。 - 覆盖需要计数、校验、日志的成员。
代码或图示
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 自动生成全部转发,只覆盖需要增强的方法,样板代码大幅减少。
概念解释
装饰器围绕同一接口包装原对象,增加日志、计数、缓存等行为。委托语法把「逐方法转发」交给编译器,外层类聚焦差异逻辑。
原理流程
- 定义统一接口。
- 被包装对象实现接口。
- 装饰类
by委托原对象。 - 覆盖方法插入前后置逻辑并调用委托对象。
代码或图示
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 接口代理生成的字节码有什么特点?
一句话结论
类委托为接口每个方法生成转发方法,方法体内调用委托对象对应方法;字节码中外层类仍是接口实现类型,实例持有委托对象引用。
概念解释
理解生成形态有助于排查委托失效、方法查找与性能问题。转发方法是普通虚方法,运行时按外层实例分派后再转发到组件。
原理流程
- 编译器扫描委托类实现的接口方法。
- 为每个方法生成转发实现。
- 方法体读取委托字段并调用同名方法。
- 覆盖方法保留外层自定义逻辑。
代码或图示
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 类加载规范保证静态初始化的排他性,不需要手写同步块。状态共享带来的可见性问题另算。
原理流程
- 编译器生成单例类与静态实例字段。
- 类加载时执行对象体初始化。
- 多线程首次访问阻塞至初始化完成。
- 后续访问共享同一实例。
代码或图示
object Counter {
private var count = 0
@Synchronized fun next(): Int = ++count
}
常见误区
- 以为单例内部变量天然线程安全:初始化安全不等于读写安全。
- 单例持有 Activity/请求级引用:跨生命周期泄漏。
追问
- 答:需要懒加载单例怎么做?答:伴生对象内用
lazy委托或工厂方法按需创建。 - 答:单例初始化抛异常会怎样?答:类初始化失败,后续访问按 JVM 类加载错误规则表现。
04.8.1.2-070 object 表达式中的局部单例与捕获规则是什么?
一句话结论
匿名对象表达式创建局部实例,可捕获外层变量;被捕获变量按闭包规则被对象持有,对象存活期间外层变量不会被回收。
概念解释
与全局 object 声明不同,对象表达式每次执行创建新实例。常用于临时回调、策略对象;捕获长生命周期变量是内存泄漏来源之一。
原理流程
- 执行到
object : 类型 {}表达式创建实例。 - 闭包捕获引用的外层变量。
- 对象方法通过捕获引用访问外层值。
- 对象被长生命周期持有后,捕获引用一并留存。
代码或图示
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 分组失效。
原理流程
- 对象加入集合,按当前集合内容计算哈希。
- 外部修改集合元素。
- 后续查找按新内容计算哈希,原桶位不匹配。
- 业务去重、缓存判断出现不一致。
代码或图示
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。嵌套可空对象同理:覆盖时传入新可空值,不覆盖保留原引用。
原理流程
- 读取原实例各属性。
- 命名参数覆盖对应可空字段。
- 未传字段沿用原值,包括
null。 - 新实例按构造规则建立。
代码或图示
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 细分领域错误、外部依赖错误等。
原理流程
- 声明 sealed
Result<out T>。 Success携带值,Failure携带错误。- 业务函数返回
Result<T>而非裸抛异常。 - 调用方
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 字段自由、生成完整值语义,但每个实例有对象开销。
原理流程
- 统计值对象字段数量:单值优先评估 value class。
- 检查框架兼容:序列化、持久化、反射是否支持。
- 评估装箱场景:是否进入大集合/可空位置。
- 多字段或兼容要求高:选 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。
原理流程
- 声明配置 data class,字段带默认值。
- 加载层合并外部配置与默认值。
- 必填字段缺失在校验期失败。
- 运行时读取只读配置实例。
代码或图示
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 是全局单例,适合无状态可复用组件;伴生对象绑定特定类,组织该类的构造与类级逻辑。两者都在类加载/首次访问时初始化。
原理流程
- 判断组件是否绑定特定类:绑定关系放伴生对象。
- 独立无状态策略用 object 实现接口。
- 多策略按名称注册到 object 注册表。
- 调用方通过对象名或伴生成员获取实例。
代码或图示
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 引用也可保存为函数类型变量。
原理流程
- 检查接口方法数量:单方法优先 lambda。
- 需要多方法或状态:对象表达式。
- lambda 赋值给函数类型变量后可反注册。
- 回调中注意捕获引用生命周期。
代码或图示
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 会增加方法计数;热点对象实例化与拷贝成本需实测,而非只看源码简洁度。
原理流程
- 编译器为类生成固定数量成员方法。
- 方法体遍历构造属性拼接比较、哈希、字符串。
- 属性规模决定单个方法字节码长度。
- 方法数随类数量线性累积。
代码或图示
data class Metric(val name: String, val value: Double, val tag: String?)
// 编译产物包含上述生成成员,方法数量与属性遍历成本可在构建产物中查看
常见误区
- 忽略 Android 方法数限制场景:超大型工程需审查细粒度值对象数量。
- 只看源码行数判断性能:生成方法体才是字节码成本主体。
追问
- 答:哪些生成成员可手写替代?答:相等性、字符串表示可覆盖;
copy/解构按需要保留。 - 答:实测手段有哪些?答:查看构建产物方法数、字节码大小与实例分配热点。
04.8.1.2-079 性能:value class 装箱消除的条件是什么?
一句话结论
在非空局部变量、非空参数与返回值等直接使用点,value class 可内联为底层类型;进入可空位置、泛型容器、跨类型边界或反射场景时退化为装箱对象。
概念解释
内联消除依赖编译器证明包装只作为底层值使用。擦除与空值要求对象表示,是装箱的主要触发条件。性能敏感代码应减少包装对象进入大集合。
原理流程
- 使用点满足直接值表示:内联展开为底层类型。
- 类型可空:需要包装对象承载
null。 - 泛型实参:擦除要求引用类型。
- 跨语言/反射边界:按对象表示处理。
代码或图示
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 实例不随页面或请求销毁,引用被长期持有。资源型成员需要显式关闭、清空或改为注入式实例,避免内存与句柄泄漏。
原理流程
- 单例创建后实例长期存活。
- 注入的外部资源被成员引用保留。
- 资源本应在作用域结束时释放,被单例延长生命周期。
- 累积后出现内存、连接或文件句柄泄漏。
代码或图示
object SessionCache {
private val holders = mutableMapOf<String, Any>()
fun clear() = holders.clear() // 作用域结束时主动清理
}
常见误区
- 在单例中缓存 Activity、Context 等页面对象。
- 只清数据不清引用类型:泄漏对象仍可达。
追问
- 答:需要按作用域持有资源怎么做?答:改为普通类实例,由作用域容器管理生命周期。
- 答:单例状态并发读写如何保护?答:按需使用同步方法或并发集合,不能依赖初始化安全。
04.8.1.2-081 坑:inner 类持有外部引用如何导致内存泄漏?
一句话结论
inner 类实例保存外部实例引用,当内部类被长生命周期结构持有时,外部实例连同其成员都无法回收,形成泄漏链。
概念解释
匿名内部类、回调、监听器是典型场景:订阅总线持有内部类实例,内部类再持有外部页面对象。外部页面应销毁时仍被引用链可达。
原理流程
- 创建
inner实例,捕获外部this。 - 长生命周期容器订阅/持有内部类。
- 引用链:容器 → 内部类 → 外部实例。
- 外部实例本应回收,但仍可达,泄漏。
代码或图示
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 类委托还包含首次计算与后续缓存读取。
概念解释
委托把属性逻辑外置,访问不再是直接字段读取。简单委托开销小,复杂委托(同步、观察、缓存)在高频访问路径上累积成本。
原理流程
- 读取属性:编译器调用委托
getValue。 - 委托内部读取缓存、计算或通知。
- 写入属性:调用
setValue并执行观察逻辑。 - 高频路径上转发与内部逻辑叠加产生开销。
代码或图示
var name by Delegates.observable("") { _, old, new -> log(old, new) }
// 每次 set 都触发回调;每次 get 都经过委托转发
常见误区
- 热循环里频繁访问委托属性:忽略转发开销。
- 委托内部持有大对象却随属性生命周期存活。
追问
- 答:
lazy首次与后续访问成本?答:首次执行计算 lambda,后续读缓存字段;线程安全模式影响同步成本。 - 答:如何优化高频访问?答:读入局部变量复用,或热点属性改为直接字段。
04.8.1.2-083 坑:伴生对象在类加载期初始化有哪些注意点?
一句话结论
伴生对象随类加载/首次访问初始化,其属性与工厂逻辑在此时建立;重初始化逻辑、外部依赖缺失会影响类加载,且状态被所有实例共享。
概念解释
伴生对象不是普通实例,类级状态全局唯一。初始化顺序、静态依赖循环与异常都会影响类可用性;把可变业务状态放伴生对象等于全局共享。
原理流程
- 类被首次引用触发类加载。
- 伴生对象字段初始化与对象体执行。
- 初始化失败按 JVM 类加载错误规则表现。
- 后续所有实例共享伴生对象状态。
代码或图示
class TokenService {
companion object {
private var cache: Map<String, String> = emptyMap()
}
}
常见误区
- 伴生对象里放请求级可变状态:跨请求污染。
- 初始化依赖远程资源:类加载期阻塞或失败。
追问
- 答:伴生对象与顶层单例对象区别?答:伴生对象绑定类访问入口,对象声明为独立全局单例。
- 答:类加载初始化异常如何排查?答:查看类初始化堆栈与伴生对象静态字段初始化顺序。
04.8.1.2-084 坑:data class 继承普通类时 equals 不对称如何表现?
一句话结论
子类加入附加字段后,父类实例与子类实例互相比较路径不同,可能 a == b 为真而 b == a 为假;集合与缓存场景下相等性判断不稳定。
概念解释
相等性契约要求对称。父类 equals 不了解子类字段,子类比较又纳入自身状态,双向调用产生不同结论。值类型层级应避免开放继承。
原理流程
- 父类实现或继承默认相等性。
- 子类 data class 生成纳入自身字段的比较。
- 父类 equals 比较子类实例时未看附加字段。
- 双向比较结果不一致,违反对称契约。
代码或图示
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 穷尽检查成立。跨模块硬加子类会破坏层级封闭,编译报错。设计时需区分「有限取值」与「预留扩展」两类需求。
原理流程
- 编译器记录 sealed 允许的子类位置范围。
- 外部模块声明子类被规则拒绝。
when穷尽性依赖子类集合完整。- 需要开放扩展:使用普通 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 仍在字节码生成对应字段与方法,只是源码不重复书写。
原理流程
- Java:声明字段 → 构造器赋值 → getter/setter。
- Kotlin:构造参数声明属性,编译器生成幕后字段与访问器。
- data class 额外生成相等性、复制、解构。
- 外部调用方式与 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 构造器与访问器的兼容。
原理流程
- Lombok 注解处理在编译期改写字节码。
- data class 由 Kotlin 编译器直接生成成员。
- 相等性/复制/解构是 data class 特有能力。
- 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 子类可携带不同数据结构。
原理流程
- Java sealed:类/接口 permits 子类,模式匹配在运行时或预览特性中演进。
- Kotlin sealed:编译器封闭子类集合,
when编译期穷尽。 - 带数据分支用 data class,单例标记用 object/data object。
- 跨语言签名按各自字节码规则呈现。
代码或图示
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 源码层用对象组织类级成员,字节码形态由注解决定。顶层函数/属性编译到文件包装类;伴生对象默认是实例成员,需要注解才暴露静态调用。
原理流程
- Java:
static成员直接属于类。 - Kotlin 伴生对象:绑定类的单例对象。
- 顶层成员:文件包装类静态形态。
- 注解控制 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 命名有调整;不同编译器版本对边界规则、警告诊断可能不同。面试与文档中不应编造固定版本号。
原理流程
- 记录项目 Kotlin 版本与标准库版本。
- 查官方文档 value class 章节的稳定状态标注。
- 最小工程验证内联、装箱、序列化与反射表现。
- 不确定结论标注「待确认」并写明验证步骤。
代码或图示
// 待确认:当前版本 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、集合只读、解释各生成成员的输入来源与用途、指出类体属性不参与生成契约。
原理流程
- 声明 data class 与构造属性。
- 说明相等性基于构造属性值。
- 说明
copy生成新实例、componentN解构顺序。 - 指出可变集合与类体属性的注意点。
代码或图示
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 覆盖全部节点类型,求值函数递归处理子节点。
原理流程
- 声明 sealed
Expr。 Num叶子携带数值,Sum内部节点持有两个子树。- 求值函数
when分派,内部节点递归。 - 新增节点类型时编译期提醒补充分支。
代码或图示
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、可见性收紧、类型不兼容。答题先复述诊断含义,再给修复并说明语义。
原理流程
- 检查类继承是否允许:父类需
open/抽象/接口。 - 检查成员是否可重写。
- 子类方法标注
override。 - 核对参数、返回类型与可见性兼容。
代码或图示
// 报错:父类 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 标准接口。
原理流程
- 定义委托类持有内部状态。
- 实现
getValue返回校验后的值。 - 可变委托实现
setValue,写入前校验。 - 属性委托声明接入。
代码或图示
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;互操作构造签名、内存泄漏风险与访问外部成员权限。
原理流程
- 写普通嵌套类:静态类,成员不可访问外部实例状态。
- 写
inner类:构造绑定外部实例,可访问外部成员。 - 对比字节码字段:inner 有外部引用字段。
- 说明长生命周期持有的泄漏风险。
代码或图示
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 局部类有哪些规则与限制?
一句话结论
类可声明在函数内部,仅在该作用域可见,可捕获外层局部变量;局部类不能有可见性修饰符,名称不对外暴露,多用于一次性辅助实现。
概念解释
局部类类似局部函数,作用域限定在声明块内。它可访问外层捕获变量,但不能被外部引用类型声明。匿名对象表达式是局部类的匿名形式。
原理流程
- 函数体内声明
class Local { ... }。 - 编译器生成作用域受限的类。
- 捕获外层局部变量按闭包规则持有。
- 函数返回后局部类类型不可被外部命名使用。
代码或图示
fun build(): List<String> {
class Accumulator { val items = mutableListOf<String>() }
val acc = Accumulator()
return acc.items
}
常见误区
- 给局部类加
private/public:可见性修饰不适用。 - 函数返回局部类实例却暴露类型:外部只能按推断类型使用。
追问
- 答:局部类与匿名对象表达式区别?答:局部类有名称可多次实例化;匿名对象一次性创建。
- 答:局部类能声明伴生对象吗?答:受语言规则限制,具体以编译器版本为准(待确认)。
04.8.1.2-097 泛型约束下的继承与重写有哪些衔接点?
一句话结论
子类类型参数、父类泛型实参与重写方法签名需要兼容;型变规则决定集合/函数类型能否替换,本页只点到衔接,完整规则见泛型章节。
概念解释
继承引入泛型实参后,子类型关系受型变约束。重写方法返回类型可协变收窄,参数方向需兼容;泛型擦除后运行时只保留外层类型。
原理流程
- 子类声明父类时传入泛型实参。
- 检查实参与父类型变标注兼容。
- 重写方法签名沿子类型规则匹配。
- 擦除后泛型实参不保留到运行时。
代码或图示
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、序列化、校验框架常通过注解读取构造属性;注解位置错误会导致框架识别不到。
原理流程
- 注解定义适用目标(参数、属性、字段、访问器)。
- 构造参数加注解按目标传播。
- 默认值参与生成重载与签名。
- 框架反射按注解目标读取元数据。
代码或图示
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 值类型适合做贫血载体:不可变属性、值语义、序列化友好;复杂规则应避免堆在数据类内部。
原理流程
- data class 声明字段与默认值。
- 业务规则放入服务类或扩展函数。
- 模型不依赖外部框架与服务。
- 需要行为聚合时再演进为富领域对象。
代码或图示
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/伴生组织工厂与单例。组合使用时遵循不可变、封装与穷尽检查原则。
原理流程
- 识别模型是值对象、状态分支还是标识类型。
- 选择对应 data/sealed/value class 载体。
- 用构造属性、委托与封装控制状态变化。
- 配合
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 官方文档:Classes — 构造器、属性、继承与可见性。
- Kotlin 官方文档:Data Classes — data class 生成成员与契约规则。
- Kotlin 官方文档:Sealed Classes — sealed 层级、interface 与穷尽检查。
- Kotlin 官方文档:Value Classes — value class 语义、装箱边界与限制。
- Kotlin 官方文档:Object Expressions and Declarations — 单例对象与匿名对象表达式。
待整理清单
- [ ] 在项目 Kotlin 2.x 版本上核对 value class 注解要求与装箱边界表现
- [ ] 核对 sealed interface、data object、
entries等 API 的版本可用性 - [ ] 补充 data class 与目标序列化/ORM 框架的互操作实测记录
- [ ] 整理委托属性、类委托在字节码层的转发示例与性能对比