Kotlin 中的 companion object 使用指南

companion object 是 Kotlin 中一个非常有用的特性，它允许你在类内部定义一个伴随对象，这个对象与类本身相关联（类似于 Java 中的静态成员，但更强大）。

基本用法

class MyClass {
    companion object {
        const val CONSTANT = "This is a constant"
        
        fun create(): MyClass = MyClass()
    }
}

主要特点

替代静态成员：

// 调用方式
val instance = MyClass.create()
val constant = MyClass.CONSTANT

可以命名：

class MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}

实现接口：

interface Factory<T> {
    fun create(): T
}

class MyClass {
    companion object : Factory<MyClass> {
        override fun create(): MyClass = MyClass()
    }
}

扩展函数：

class MyClass {
    companion object 
}

fun MyClass.Companion.printHello() {
    println("Hello")
}

// 使用
MyClass.printHello()

与 Java 互操作

Kotlin 的 companion object 成员在 Java 中可以通过 Companion 访问：

// Java 中调用
MyClass.Companion.create();

如果你想在 Java 中像静态成员一样使用，可以添加 @JvmStatic 注解：

companion object {
    @JvmStatic
    fun create(): MyClass = MyClass()
}

这样在 Java 中就可以直接调用 MyClass.create()。

实际应用场景

工厂方法：

class User private constructor(val name: String) {
    companion object {
        fun create(name: String): User {
            return User(name)
        }
    }
}

常量定义：

class Constants {
    companion object {
        const val API_URL = "https://api.example.com"
    }
}

单例模式：

class Singleton {
    companion object {
        val instance: Singleton by lazy { Singleton() }
    }
}

注意事项

• companion object 在类加载时初始化（类似于 Java 的静态初始化）
• 每个类只能有一个 companion object
• companion object 可以访问类的私有成员
• companion object 是 Kotlin 中实现类级别功能和数据的优雅方式，比 Java 的静态成员更灵活和强大。