独立实例类重写方法：多层修饰Parent子类act()的实现方案咨询

需求可行性分析 #

完全可行，你要的就是装饰器模式的典型应用场景——动态给对象添加额外功能，支持任意多层组合，而且不用修改原有类的代码。

修正原有基础代码 #

你原来的Child1/Child2代码缺少override关键字，先补全可用的基础代码：

abstract class Parent {
    abstract fun prepare()
    abstract fun act()
}

class Child1 : Parent() {
    override fun prepare() {
        println("Child1 准备工作")
    }

    override fun act() {
        println("Child1 执行核心操作")
    }
}

class Child2 : Parent() {
    override fun prepare() {
        println("Child2 准备工作")
    }

    override fun act() {
        println("Child2 执行核心操作")
    }
}

实现装饰器类 #

每个装饰器都继承Parent，内部持有一个Parent类型的被装饰对象：

• 不需要修改的prepare()方法直接转发给被装饰对象
• 重写act()方法，在调用被装饰对象的act()前后添加自定义逻辑

示例装饰器实现：

// 装饰器1：在act前后添加通用操作
class Modify1(private val wrapped: Parent) : Parent() {
    override fun prepare() {
        wrapped.prepare() // 直接转发原逻辑
    }

    override fun act() {
        println("Modify1: 执行act前的前置检查")
        wrapped.act()
        println("Modify1: 执行act后的收尾处理")
    }
}

// 装饰器2：添加日志记录逻辑
class Modify2(private val wrapped: Parent) : Parent() {
    override fun prepare() {
        wrapped.prepare()
    }

    override fun act() {
        println("Modify2: 开始记录操作日志")
        wrapped.act()
        println("Modify2: 操作日志记录完成")
    }
}

// 装饰器3：添加性能监控逻辑
class Modify3(private val wrapped: Parent) : Parent() {
    override fun prepare() {
        wrapped.prepare()
    }

    override fun act() {
        val startTime = System.currentTimeMillis()
        wrapped.act()
        val cost = System.currentTimeMillis() - startTime
        println("Modify3: act方法耗时 $cost ms")
    }
}

灵活组合使用 #

完全支持你想要的任意嵌套组合，不管是原始实例还是已装饰的实例都可以作为参数传入：

fun main() {
    // 多层装饰：Child1先被Modify3监控，再被Modify1增强
    val modifiedChild1: Parent = Modify1(Modify3(Child1()))
    modifiedChild1.prepare()
    modifiedChild1.act()
    println("---")

    // 单层装饰：Child2仅被Modify1增强
    val modifiedChild2: Parent = Modify1(Child2())
    modifiedChild2.prepare()
    modifiedChild2.act()
    println("---")

    // 未装饰的原始实例
    val notModified1: Parent = Child1()
    notModified1.prepare()
    notModified1.act()
}

运行后输出示例：

Child1 准备工作
Modify1: 执行act前的前置检查
Child1 执行核心操作
Modify3: act方法耗时 0 ms
Modify1: 执行act后的收尾处理
---
Child2 准备工作
Modify1: 执行act前的前置检查
Child2 执行核心操作
Modify1: 执行act后的收尾处理
---
Child1 准备工作
Child1 执行核心操作

核心原理 #

每个装饰器都和原始类一样继承自Parent，所以可以无缝替换原始对象；同时内部持有被装饰的Parent实例，调用方法时先执行自定义逻辑，再转发给被装饰对象，多层嵌套时就会按顺序执行所有装饰器的逻辑，最后执行原始对象的核心操作。

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