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。为Actions实施 Redo

    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。

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

我一直在考虑设计结构以实现这些要求，但是我认为这可能是一个很好的结构。这会是“好方法”吗？

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()

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

1 个答案: