Question

我有一个看起来像

的枚举

public enum MyEnum
{
  myValue
  {
    @Override
    public String myMethod(String dostuff)
    {
      return dostuff + "One";
    }
  },
  myOtherValue
  {
    @Override
    public String myMethod(String dostuff)
    {
      return dostuff + "Two";
    }
  },
  aThirdValue
  {
    @Override
    public String myMethod(String dostuff)
    {
      return dostuff + "Three";
    }
  };

  public abstract String myMethod(String dostuff);
}

现在我想我们都同意这看起来很糟糕？但是更好的方式是什么？我可以有一个abstractfactory，但后来我需要三个实现类，每个实现类作为一行方法。不要觉得这么漂亮。我可以使用开关（在代码或枚举中）。但后来我忘了添加一个案例。

那么，最后的路是什么？必须有一个模式，但似乎找不到一个。到目前为止，最好的香港专业教育学院提出的意见是在Netbeans中添加自动崩溃方法的评论，也不是那么精彩。

Answer 1

解决方案是为枚举创建一个私有构造函数：

public enum MyEnum
{
  myValue("One"), myOtherValue("Two"), aThirdValue("Three");

  private String value;

  private MyEnum(String value) { this.value = value; }

  public String myMethod(String dostuff)
  {
    return dostuff + value;
  }
}

[编辑]请注意，您可以传递更复杂的内容。例如，您可以传入一个实现某个界面的类（比如Work，它有一个方法doWork()）。这样，您可以在枚举中存储方法调用以执行不同类型的工作。

查看command pattern或strategy pattern。

Answer 2

这很丑陋，但解决这个问题的非平凡扩展的大多数解决方案都只会让丑陋的事情发生。

例如，您可以将三种不同的行为封装在某个接口的三个不同实现中，然后将不同的行为实现传递给每个枚举的构造函数。（这基本上是其他人建议的命令或战略方法。）

如果你进行这些实现，并且接口是单独的类，那么你可能会将这种行为暴露在枚举之外，这是不必要的，也可能是丑陋的。

如果你将它们作为枚举的私有静态内部类，你就会将丑陋从文件顶部移动到文件的底部。在旁观者的眼中，这是多么少丑陋。

public enum Foo {

    ONE(new OneDelegate()), 
    TWO(new TwoDelegate()),
    THREE(new ThreeDelegate());

    // ////////////////////
    // Private stuff

    private final FooDelegate delegate;

    private Foo(FooDelegate delegate) {
        this.delegate = delegate;
    }

    // ////////////////////
    // Public methods

    public String doStuff(String stuff) {
        return delegate.doStuff(stuff);
    }

    // ////////////////////
    // Helper classes

    private static interface FooDelegate {
        String doStuff(String stuff);
    }

    private static class OneDelegate implements FooDelegate {
        @Override
        public String doStuff(String stuff) {
            return "One " + stuff;
        }
    }

    private static class TwoDelegate implements FooDelegate {
        @Override
        public String doStuff(String stuff) {
            return "Two " + stuff;
        }
    }

    private static class ThreeDelegate implements FooDelegate {
        @Override
        public String doStuff(String stuff) {
            return "Three " + stuff;
        }
    }
}

另一个明显的解决方案是将所有三种行为作为私有方法放入，并在公共方法中放置switch(this)。就我个人而言，我认为这是罪恶，但很多前C程序员似乎都喜欢它。 :)

public enum Foo {

    ONE, TWO, THREE;

    // ////////////////////
    // Public methods

    public String doStuff(String stuff) {
        switch(this) {
            case ONE:
                return doStuffOne(stuff);
            case TWO:
                return doStuffTwo(stuff);
            case THREE:
                return doStuffThree(stuff);

    // If we're handing all enum cases, we shouldn't need
    // a default (and per comments below, if we leave out
    // the default, we get the advantage that the compiler
    // will catch it if we add a new enum value but forget
    // to add the corresponding doStuff() handler

    //      default:
    //          throw new IllegalStateException("Who am I?");
        }
    }

    // ////////////////////
    // Static helpers

    private static String doStuffOne(String stuff) {
            return "One " + stuff;
    }

    private static String doStuffTwo(String stuff) {
            return "Two " + stuff;
    }

    private static String doStuffThree(String stuff) {
            return "Three " + stuff;
    }
}

Answer 3

怎么样？

     public enum MyEnum {
         myValue("One"),
         myOtherValue("Two"),
         aThirdValue("Three");

        private final String postfix;
        private MyEnum(String postfix) {
          this.postfix )= postfix;
        }
        public String myMethod(String dostuff) {
          return dostuff + postfix;
        }
      }

即使您的真实内容更复杂，也有几种技术可以实现这些改进。请发布您的真实需求...

一个带有enum的java方法类

3 个答案: