Kotlin：如何在抽象类中调用伴生对象实现子类统一创建方法

这问题我太熟了！在Kotlin里要实现每个子类都能通过A.create()、B.create()这种方式生成实例，最贴合需求的是用伴生对象（Companion Object），另外还有更通用的泛型方案可以备选，我给你详细拆解：

方案一：伴生对象（最贴合你的调用需求） #

Kotlin的伴生对象相当于Java里的静态成员，我们可以给每个子类单独定义伴生对象，在里面实现create方法，既能满足A.create()的调用方式，还能灵活处理子类特有的初始化逻辑。

基础实现 #

abstract class Base() {}

class A : Base() {
    // 给A类定义伴生对象，实现create方法
    companion object {
        fun create(): A {
            // 这里写初始化逻辑：比如通用初始化、子类专属配置
            val instance = A()
            // 示例：添加通用初始化步骤（如果有）
            instance.doCommonInit()
            // 示例：子类特有的初始化
            instance.doASpecificInit()
            return instance
        }
    }

    private fun doCommonInit() {
        println("所有子类通用的初始化操作")
    }

    private fun doASpecificInit() {
        println("A类专属的初始化操作")
    }
}

class B : Base() {
    companion object {
        fun create(): B {
            val instance = B()
            instance.doCommonInit()
            // B类自己的初始化逻辑
            return instance
        }
    }

    private fun doCommonInit() {
        println("所有子类通用的初始化操作")
    }
}

优化：复用通用初始化逻辑 #

如果多个子类的初始化逻辑有重复，别复制粘贴！可以把通用逻辑抽到父类Base里，用protected修饰让子类能访问：

abstract class Base() {
    // 通用初始化逻辑，子类可以直接调用
    protected fun commonInit() {
        println("统一执行通用初始化")
    }
}

class A : Base() {
    companion object {
        fun create(): A {
            val a = A()
            a.commonInit() // 调用父类的通用方法
            // A类专属逻辑
            return a
        }
    }
}

如果子类构造函数需要参数，也可以在create方法里接收并传递：

class A(private val id: Int) : Base() {
    companion object {
        fun create(id: Int): A {
            val a = A(id)
            a.commonInit()
            return a
        }
    }
}

// 调用方式：val a = A.create(100)

方案二：泛型+Reified函数（减少重复代码） #

如果所有子类的create逻辑几乎一致，只是生成不同的实例，可以用Kotlin的inline reified泛型函数，把create方法统一放到Base的伴生对象里，虽然调用方式是Base.create<A>()，但能避免重复写伴生对象：

abstract class Base() {
    companion object {
        inline fun <reified T : Base> create(): T {
            // 通过反射创建实例（要求子类有默认构造函数）
            val instance = T::class.java.getDeclaredConstructor().newInstance()
            // 执行通用初始化
            instance.commonInit()
            return instance
        }
    }

    protected fun commonInit() {
        println("通用初始化")
    }
}

// 调用方式：
val a = Base.create<A>()
val b = Base.create<B>()

方案选择建议 #

• 如果你必须要A.create()这种直观的调用方式，或者每个子类的初始化逻辑差异较大，选方案一（伴生对象）。
• 如果所有子类初始化逻辑高度统一，想减少重复代码，选方案二（泛型函数）。

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