实现单例模式：何时选择companion object而非object关键字？

1. 需要和外部类的私有成员交互时 #

Companion object属于外部类的一部分，可直接访问外部类的私有构造方法、私有属性/方法，而独立Object类没有这个权限。这在实现高封装性逻辑时尤其实用，比如限制外部类的实例创建方式：

class User private constructor(val name: String) {
    // 伴生对象可直接调用私有构造
    companion object {
        fun create(name: String): User {
            require(name.isNotBlank()) { "用户名不能为空" }
            return User(name)
        }
    }
}

// 若用独立Object，必须放开User的构造权限，破坏封装
object UserFactory {
    // 这里User构造需改为internal或public
    fun create(name: String): User = User(name)
}

2. 作为外部类的专属入口/工厂 #

当单例的职责是为外部类提供实例创建、配置解析等类级服务时，放在companion object里语义更清晰——这个单例就是外部类的“附属组件”，而非独立工具类。比如：

class Config private constructor(val properties: Map<String, String>) {
    companion object {
        // 加载配置的逻辑属于Config类本身
        fun loadFromFile(path: String): Config {
            val props = loadPropertiesFile(path)
            return Config(props)
        }
    }
}

// 调用时直接通过类名访问，符合直觉
val config = Config.loadFromFile("/app/config.properties")

3. 实现与外部类强绑定的接口 #

如果需要一个单例实现某个接口，且该接口逻辑完全服务于外部类，用companion object能让代码结构更紧凑，避免创建额外独立类。比如RecyclerView适配器的DiffCallback：

class MyItemAdapter(private val items: List<MyItem>) : RecyclerView.Adapter<MyItemAdapter.ViewHolder>() {
    // DiffCallback是适配器的专属逻辑，放在伴生对象更合理
    companion object : DiffUtil.ItemCallback<MyItem>() {
        override fun areItemsTheSame(oldItem: MyItem, newItem: MyItem): Boolean {
            return oldItem.id == newItem.id
        }

        override fun areContentsTheSame(oldItem: MyItem, newItem: MyItem): Boolean {
            return oldItem == newItem
        }
    }

    // ... 适配器其他逻辑
}

4. 优化Java互操作性 #

在Java代码中调用Kotlin companion object的成员，语法和调用Java静态方法完全一致（User.create(...)）；而调用独立Object的成员，必须通过INSTANCE访问（UserFactory.INSTANCE.create(...)），冗余且不符合Java开发者习惯。若项目需兼容Java，companion object是更优选择。

5. 复用外部类的泛型上下文 #

当外部类是泛型类时，companion object的方法可直接复用外部类的泛型参数，无需额外声明，代码更简洁：

class Box<T> private constructor(val value: T?) {
    companion object {
        // 直接使用外部类的泛型T，语义连贯
        fun <T> empty(): Box<T> = Box(null)
        fun <T> of(value: T): Box<T> = Box(value)
    }
}

// 若用独立Object，需重复声明泛型
object BoxFactory {
    fun <T> empty(): Box<T> = Box(null)
}

补充：什么时候用独立Object？ #

当单例的职责是全局通用、与特定类无关联的工具逻辑时，比如全局字符串工具、日期工具类，优先用独立Object：

object StringUtils {
    fun capitalize(s: String): String = s.replaceFirstChar(Char::uppercase)
}

内容的提问来源于stack exchange，提问作者Muhammad Shakeel