以这种方式使用伴随对象（静态）可能是一个很好的例子吗？

Question

在我的应用程序中，用户可以执行一些操作，包括 redo 支持。

因此，我觉得需要通过对象化来管理Action，我实现如下

1.实施RecoverableAction

abstract class RecoverableAction {
    abstract fun getActionName(): String
    abstract fun run()
    abstract fun undoActionName(): String

    enum class List(val action: RecoverableAction) {
        CONTAINER_CREATE(ContainerActions.CREATE), 
        CONTAINER_COPY(ContainerActions.COPY), 
        CONTAINER_DELETE(ContainerActions.DELETE)
    }
}

2。为 Redo

实施 Actions

    class ContainerActions private constructor() {
        companion object {
            val CREATE = object : RecoverableAction {
                override fun run() {
                    //do create
                }
                override fun getActionName() = List.CONTAINER_CREATE.name
                override fun undoActionName() = List.CONTAINER_DELETE.name
            }

            val DELETE = object : RecoverableAction {
                override fun run() {
                    //do create
                }
                override fun getActionName() = List.CONTAINER_CREATE.name
                override fun undoActionName() = List.CONTAINER_DELETE.name
            }

            val COPY = object : RecoverableAction {
                override fun run() {
                    //do copy
                }
                override fun getActionName() = List.CONTAINER_CREATE.name
                override fun undoActionName() = List.CONTAINER_DELETE.name
            }
        }
    }

3. 做 Action 任何地方 2 方式

    CotainerActions.CREATE.run()
    RecoverableAction.List.CONTAINER_COPY.action.run()

我不喜欢使用 static 变量，但我不希望每个 Action 每次从用户执行时都被实例化。我还将它实现为 companion，这样我就可以直接从几个不同的类.

运行相应的 Action

此外，我需要通过将用户执行的操作管理为stack来实现redo功能。我将 RecoverableAction 支持的 Action 实现为 enum 的原因是因为我想通过 name 而不是 Action object 在 Action record stack 中管理它。

我一直在考虑设计实现这些要求的结构，但我认为这可能是一个很好的结构。这会是 "good way" 吗？

Answer 1

对我来说，

RecoverableAction.List.CONTAINER_COPY.action.run()

看起来很乱。

为什么不呢：

sealed class RecoverableActions {
    abstract val actionName: String

    abstract val undoActionName: String

    abstract fun run()

    object CreateAction : RecoverableActions() {
        override fun run() {
            //do create
        }
        override val actionName = CreateAction::class.java.simpleName
        override val undoActionName = DeleteAction::class.java.simpleName
    }

    object DeleteAction : RecoverableActions() {
        override fun run() {
            //do create
        }
        override val actionName = DeleteAction::class.java.simpleName
        override val undoActionName = CreateAction::class.java.simpleName
    }

    object CopyAction : RecoverableActions() {
        override fun run() {
            //do create
        }
        override val actionName = CopyAction::class.java.simpleName
        override val undoActionName = CopyAction::class.java.simpleName // ?
    }
}

和

RecoverableActions.CreateAction.run()

以这种方式使用伴随对象（静态）可能是一个很好的例子吗？

Could be a good example of using a companion object (static) this way?

java

android

kotlin

companion-object