枚举方法覆盖[关闭]答案

【问题标题】：Enum method overriding [closed]枚举方法覆盖[关闭]
【发布时间】：2013-02-19 21:46:07
【问题描述】：

我发现Enums 的定义如下：

public Enum MyEnum {

   ONE
   {
      @Override
      public int getSomething() {
         return 1;
      } 
   },

   TWO
   {
      @Override
      public int getSomething() {
        return 2;
      }
   }

   int getSomething()
   {
      return 0;
   }
}

不知何故，我对这种实现感到某种不适，因为我认为理想情况下应该为此目的定义一个字段，并且该类应该类似于：

public Enum MyEnum{

   ONE(1),
   TWO(2)

   private int theSomething;

   private MyEnum(int something) {
      theSomething = something;
   }

   int getSomething()
   {
      return theSomething;
   }
}

问题在于，除了个人不适之外，我找不到任何好的理由来更改此代码。有吗？

【问题讨论】：

第二种形式使其更具可读性和可扩展性，选择那个！
在您的第一个示例中，它是一个 状态机。没有完全正确地实现（getSomething() 应该是抽象的）......但这就是你使用那种结构的原因。在实际示例中，这些方法通常要复杂得多（它们实际上是在做事情而不是返回静态值）和/或在当前状态下不应调用它们时抛出 IllegalStateException。
这两种方法都是有效的。

标签： java coding-style enums

【解决方案1】：

（从评论中移出）

您的第一个示例通常用于在 Java 中实现 finite state machine。它消除了每个方法都必须有 if (state == FOO) {} else if (state == BAR) 等的需要

class MyFSM {

    enum State {
        FIRST_STATE {
            @Override
            void start(MyFSM fsm) {
                fsm.doStart();
            }
            @Override
            void stop(MyFSM fsm) {
                throw new IllegalStateException("Not Started!");
            }
        },
        SECOND_STATE {
            @Override
            void start(MyFSM fsm) {
                throw new IllegalStateException("Already Started!");
            }
            @Override
            void stop(MyFSM fsm) {
                fsm.doStop();
            }
        };

        abstract void start(MyFSM fsm);
        abstract void stop(MyFSM fsm);       
    }

    private volatile State state = State.FIRST_STATE;

    public synchronized void start() {
        state.start(this);
    }

    private void doStart() {
        state = SECOND_STATE;
    }

    public synchronized void stop() {
        state.stop(this);
    }

    private void doStop() {
        state = FIRST_STATE;
    }
}

【讨论】：

案例是使用简单的枚举，只是getter方法。但很高兴知道这一点，谢谢！
那么它是矫枉过正，恕我直言。有效......但矫枉过正。以上是我使用它的唯一原因。

【解决方案2】：

对于不需要全部覆盖的“默认”方法，第一种模式稍微好一些。

public enum Modes {
    MODE_ONE {
        @Override public boolean canDoA() {
            return true;
        }
    },
    MODE_TWO {
        @Override public boolean canDoB() {
            return true;
        }
    },
    MODE_THREE {
        @Override public boolean canDoC() {
            return true;
        }
    };

    public boolean canDoA() {
        return false;
    }

    public boolean canDoB() {
        return false;
    }

    public boolean canDoC() {
        return false;
    }

}

【讨论】：