Java 国家模式实施困难

我在应用程序中使用

状态模式

，因为我的

状态实体

具有API，其行为因当前状态而改变

在我的例子中，依赖于状态的API只由一个方法组成-

changeState

。该方法改变状态并执行一些状态相关逻辑

但是有一种情况让我提出了这个问题：依赖于状态的逻辑不仅依赖于当前状态，而且还依赖于newState（参见下面的代码）。所以我必须使用

instanceof

问题：摆脱

实例的真正方法是什么

编辑（为什么不枚举）：

如果枚举替换了一个
getClass（）.getSimpleName（）
：因为它是函数式编程范例。当我以依赖于类名的方式构建架构时，这是出现问题的第一个迹象。在我看来，将
instanceof
更改为
enum
并不意味着要更改架构，而只是将一个坏的架构更改为更坏的架构

如果将每个IState实现设为enum：每个IState实现都是Hibernate实体。
在Java中，创建单例的公认方法是使用
enum
。这提供了线程安全的初始化以及JVM保证的单例状态。有许多方法可以创建非
枚举的
类的第二个实例

使用
enum
的另一个好处是，您可以在逻辑中打开
enum
：

public enum State {

    STATE_A {
        @Override
        public void doStateDependentLogic(final State newState) {
            switch (newState) {
                case STATE_B:
                    //do stuff
                //case SOME_OTHER_STATE
            }
        }
    },
    STATE_B {
        @Override
        public void doStateDependentLogic(final State newState) {
        }
    };

    public abstract void doStateDependentLogic(State newState);
}

我不知道你是从哪里知道
enum
是一种函数式编程范例的。事实并非如此enum
被设计为完全满足您的需要。
Java中创建单例的公认方法是使用
enum
。这提供了线程安全的初始化以及JVM保证的单例状态。有许多方法可以创建非
枚举的
类的第二个实例

使用
enum
的另一个好处是，您可以在逻辑中打开
enum
：

public enum State {

    STATE_A {
        @Override
        public void doStateDependentLogic(final State newState) {
            switch (newState) {
                case STATE_B:
                    //do stuff
                //case SOME_OTHER_STATE
            }
        }
    },
    STATE_B {
        @Override
        public void doStateDependentLogic(final State newState) {
        }
    };

    public abstract void doStateDependentLogic(State newState);
}

我不知道你是从哪里知道
enum
是一种函数式编程范例的。事实并非如此enum
被设计为完全满足您的需要。
Java中创建单例的公认方法是使用
enum
。这提供了线程安全的初始化以及JVM保证的单例状态。有许多方法可以创建非
枚举的
类的第二个实例

使用
enum
的另一个好处是，您可以在逻辑中打开
enum
：

public enum State {

    STATE_A {
        @Override
        public void doStateDependentLogic(final State newState) {
            switch (newState) {
                case STATE_B:
                    //do stuff
                //case SOME_OTHER_STATE
            }
        }
    },
    STATE_B {
        @Override
        public void doStateDependentLogic(final State newState) {
        }
    };

    public abstract void doStateDependentLogic(State newState);
}

我不知道你是从哪里知道
enum
是一种函数式编程范例的。事实并非如此enum
被设计为完全满足您的需要。
Java中创建单例的公认方法是使用
enum
。这提供了线程安全的初始化以及JVM保证的单例状态。有许多方法可以创建非
枚举的
类的第二个实例

使用
enum
的另一个好处是，您可以在逻辑中打开
enum
：

public enum State {

    STATE_A {
        @Override
        public void doStateDependentLogic(final State newState) {
            switch (newState) {
                case STATE_B:
                    //do stuff
                //case SOME_OTHER_STATE
            }
        }
    },
    STATE_B {
        @Override
        public void doStateDependentLogic(final State newState) {
        }
    };

    public abstract void doStateDependentLogic(State newState);
}

我不知道你是从哪里知道
enum
是一种函数式编程范例的。事实并非如此enum
被设计为完全满足您的需求。
您的问题实际上不是状态模式。问题在于状态模式完成了它的工作（将方法调用路由到表示状态的特定实现）之后

子类的
实例问题是一个独立的问题。这里的解决方案是避免类似于其他代码的
instanceof
，最好通过方法在状态和下一个状态之间进行交互
switch
over
enum
类型看起来已经很好了，但并没有太好，因为您仍然依赖于另一个对象的具体类型。可以认为没有问题，因为它们都是在同一个类中定义的，所以依赖关系只取决于您自己

在最好的情况下，你最终应该得到什么

  @Override
  public void doStateDependentLogic(IState newState) {
     if (newState.isBeautiful()) {
         System.out.println(newState.getYourPartOfTheInterAction(this));
     } else {
         somethingElse();
     }
  }

i、 方法调用抽象而不关心实现细节。
您的问题实际上不是状态模式。问题在于状态模式完成了它的工作（将方法调用路由到表示状态的特定实现）之后

子类的
实例问题是一个独立的问题。这里的解决方案是避免类似于其他代码的
instanceof
，最好通过方法在状态和下一个状态之间进行交互
switch
over
enum
类型看起来已经很好了，但并没有太好，因为您仍然依赖于另一个对象的具体类型。可以认为没有问题，因为它们都是在同一个类中定义的，所以依赖关系只取决于您自己

在最好的情况下，你最终应该得到什么

  @Override
  public void doStateDependentLogic(IState newState) {
     if (newState.isBeautiful()) {
         System.out.println(newState.getYourPartOfTheInterAction(this));
     } else {
         somethingElse();
     }
  }

i、 方法调用抽象而不关心实现细节。
您的问题实际上不是状态模式。问题在于状态模式完成了它的工作（将方法调用路由到表示状态的特定实现）之后

子类的
实例问题是一个独立的问题。这里的解决方案是避免类似于其他代码的
instanceof
，最好通过方法在状态和下一个状态之间进行交互
switch
over
enum
类型看起来已经很好了，但也没有太好，因为您仍然依赖于conc