时间戳

首页 > 解决方案 > 以这种方式使用伴生对象（静态）可能是一个很好的例子吗？

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

问题描述

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

因此，我觉得有必要通过 objectizing 来管理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. 我实现 Action supported by RecoverableActionas anenum的原因是因为我想在Action record stackbyname而不是Action object.

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

标签： javaandroidkotlincompanion-object

解决方案

对我来说，

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

推荐阅读