深入解析：Kotlin 中companion object {} 什么时候触发

在 Kotlin 中，companion object 的初始化触发时机是一个重要但容易被忽视的细节。以下是详细的解释：

1. 基本触发时机

companion object 的初始化发生在：

• 首次访问该类时（无论是访问伴生对象成员、创建类实例，还是通过反射访问类）

• 类似于 Java 的静态初始化块，但更灵活

• class MyClass {
  companion object {
  init {
  println("Companion object 初始化!")
  }
  val CONST = "Hello"
  }
  }
  
  fun main() {
  println("程序启动")
  MyClass.CONST // 第一次访问 MyClass 时触发初始化
  }

 输出：

程序启动
Companion object 初始化!

2. 具体触发场景

以下操作都会触发 companion object 初始化：

(1) 直接访问伴生对象成员

MyClass.CONST          // 触发
MyClass.Companion      // 触发

(2) 创建类实例

val obj = MyClass()    // 触发

(3) 通过反射访问类

MyClass::class          // 触发（Kotlin 反射）

(4) 访问类的其他声明

MyClass::class          // 触发（Kotlin 反射）

3. 不会触发的情况

以下操作不会触发初始化：

// 仅声明类型（未实际访问）
val clazz: Class = MyClass::class.java

// 作为类型参数（未实例化或访问）
fun process(clazz: Class<*>) {}
process(MyClass::class.java) // 不会触发

4. 与 Java 静态初始化的对比

特性	Kotlin companion object	Java static 块
初始化时机	首次访问类时	类加载时
懒加载	是（按需初始化）	否（类加载时强制初始化）
线程安全	是（JVM 保证）	是

5. 实际应用中的注意事项

(1) 性能优化

class HeavyInitialization {
companion object {
val HEAVY_RESOURCE = loadResource() // 避免在伴生对象中放重型初始化
}
}

// 改为懒加载
class BetterApproach {
companion object {
val heavyResource by lazy { loadResource() }
}
}

(2) 循环依赖问题

class A {
companion object {
val VALUE = B.VALUE // 如果 B 的伴生对象也依赖 A，会导致栈溢出
}
}

class B {
companion object {
val VALUE = A.VALUE
}
}

解决方案：使用 lazy 延迟初始化

class A {
companion object {
val VALUE by lazy { B.VALUE }
}
}

6. 验证示例

class Test {
companion object {
init { println("伴生对象初始化") }
}

init { println("类实例初始化") }
}

fun main() {
println("阶段1")
Test::class // 仅访问 KClass，不触发

println("阶段2")
Test.Companion // 触发初始化

println("阶段3")
Test() // 伴生对象已初始化，不会再次触发
}

输出：

阶段1
阶段2
伴生对象初始化
阶段3
类实例初始化

总结

• companion object 在首次真正使用类时初始化（懒加载）
• 比 Java 的静态初始化更灵活，但逻辑相似
• 适合存放类级别的常量、工厂方法等
• 避免在伴生对象中直接进行重型操作，建议用 by lazy