Kotlin：子类实例化时如何避免执行父类init块代码

父类的init块在子类实例化时必然会执行，所以直接修改init块本身不可行，得从设计层面调整。下面是几个比“公开可重写initMethod”更合规的解决方案：

方案1：用构造参数开关控制输出逻辑 #

给父类加一个可选参数，用来控制是否执行指定的输出逻辑，子类实例化时传入false关闭该逻辑。

open class Parent(private val enableInitLog: Boolean = true) {
    init {
        // 只在开关开启时执行输出
        if (enableInitLog) {
            println("This is a parent object")
        }
        // 父类核心初始化逻辑（不受开关影响）
    }
}

class Child : Parent(enableInitLog = false) {
    // 子类自定义逻辑
}

fun main() {
    Child() // 不会输出父类的指定消息
}

这种方式既保留了父类核心初始化的完整性，又给子类提供了选择空间，符合开闭原则，还避免了公开可重写方法带来的子类篡改风险。

方案2：分离可选逻辑到protected方法，子类按需触发 #

把非必须的输出逻辑提取到父类的protected方法中，父类提供不同构造函数：一个默认调用该方法，另一个跳过。子类通过选择构造函数来控制是否执行输出。

open class Parent {
    // 父类默认构造：执行可选输出逻辑
    constructor() {
        initOptionalLog()
        // 父类核心初始化
    }

    // 供子类使用的构造：跳过可选逻辑
    protected constructor(skipOptionalInit: Boolean) {
        // 只执行核心初始化
    }

    protected fun initOptionalLog() {
        println("This is a parent object")
    }
}

class Child : Parent(skipOptionalInit = true) {
    // 子类逻辑
}

fun main() {
    Child() // 无指定输出
}

这种方式把可选逻辑和核心逻辑解耦，父类内部逻辑保持封装，子类只能通过预设的构造入口控制行为，不会破坏父类的预期流程。

方案3：用委托模式替代继承 #

如果只需要复用父类的部分功能，而非完全继承它的所有行为，可以用委托模式避开父类init块的执行。

// 定义父类需要暴露的功能接口
interface ParentFunc {
    fun doSomething()
}

// 原父类实现接口
class ParentImpl : ParentFunc {
    init {
        println("This is a parent object")
    }

    override fun doSomething() {
        // 功能实现
    }
}

// 子类通过委托复用功能，延迟初始化委托对象
class Child : ParentFunc {
    // 只有调用功能方法时才初始化委托对象
    private val parentDelegate by lazy { ParentImpl() }

    override fun doSomething() {
        parentDelegate.doSomething()
    }
}

fun main() {
    Child() // 初始化时不会触发ParentImpl的init，也就不会输出指定消息
}

委托模式让你完全控制父类实现的初始化时机，甚至可以按需避免不必要的初始化，适合不需要完整继承父类行为的场景。

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