Question

以下哪两种方法会更好？我选择了枚举，因为在典型的情况下，亚型多态性是最好的方法;这也是编写简单工厂方法时的典型方法。

public class SomeClass {
    public SomeEnum returnAType(String someString) {
        //implementation bellow
   }

   private boolean method1() {
   //...
   }

   private boolean method2() {
   //...
   }

   private boolean method3() {
   //...
   }

}

returnATypeMethod的第一个实现;这个更快，因为如果method1有效，它不会调用method2和method3（可能还有更多）。

    public SomeEnum returnAType(String someString) {
        if(method1(someString)) {
            SomeEnum.ENUM1.doSomething();
            return SomeEnum.ENUM1;
        }
        if(method2(someString)) {
            SomeEnum.ENUM2.doSomething();
            return SomeEnum.ENUM2;
        }
        if(method3(someString)) {
            SomeEnum.ENUM3.doSomething();
            return SomeEnum.ENUM3;
        }
        SomeEnum.DEFAULT_ENUM.doSomething();
        return SomeEnum.DEFAULT_ENUM;
   }

returnATypeMethod的第二个实现;这个更清楚，没有代码重复：

    public SomeEnum returnAType(String someString) {
        SomeEnum enumType = SomeEnum.DEFAULT_ENUM;
        if(method1(someString)) {
            enumType = SomeEnum.ENUM1;
        }
        if(method2(someString)) {
            enumType = SomeEnum.ENUM2;            }
        }
        if(method3(someString)) {
            enumType = SomeEnum.ENUM3;
        }
        enumType.doSomething();
        return enumType;
   }

Answer 1

我很想使用

public SomeEnum returnAType(String someString) {
    SomeEnum enumType = method1(someString) ? SomeEnum.ENUM1 :
                        method2(someString) ? SomeEnum.ENUM2 :
                        method3(someString) ? SomeEnum.ENUM3 : SomeEnum.DEFAULT_ENUM;
    enumType.doSomething();
    return enumType;

}

Answer 2

我发现Java枚举令人困惑，一般情况下我会建议当你不是简单地枚举时尽量避免枚举。您可以将代码组织到接口或抽象类以及实现该接口或抽象类的几个单例中。最终设计更清晰，更易理解。

我热烈建议尽量避免使用返回T的方法，并在中调用t.someMethod。这种模式再次令人困惑和误导。 将您的returnAType视为单身人士的工厂方法，此功能的目标只是为您提供正确的单身人士类型

如果您的函数不使用某些模式但使用简单的等式，请使用数据结构来存储键值关联。有人说不是EnumMap，因为在EnumMap中，Enum是关键，而不是价值。

事实上，@ Peter Lawrey收到的评论强调了如果你不遵循第二个建议就会遇到的问题：不要写一个返回t的方法，并通过t产生副作用。我的建议是部分遵循其建议，但以这种方式将副作用移到外面：

// Beautiful and testable with no side-effects

public SomeEnum returnAType(String someString) {
    SomeEnum enumType = method1(someString) ? SomeEnum.ENUM1 :
                        method2(someString) ? SomeEnum.ENUM2 :
                        method3(someString) ? SomeEnum.ENUM3 : SomeEnum.DEFAULT_ENUM;

    return enumType;
}

// Do something for real
public void doSomethingWith(String someString) {
    SomeEnum enumType = returnAType(someString);
    enumType.doSomething();
}

Answer 3

在Java 7中，您可以将switch与String：

一起使用

使用构造函数SomeEnum在其他地方编译SomeEnum(Integer) {..;}。

它可以是private，例如Pattern.class示例，因此它是return SomeEnum.set(1);。

public SomeEnum returnAType(final String someString) {
     switch (someString.toLowerCase()) { //toLowerCase() if needed
        case "one":
            return new SomeEnum(1);
            break;
        case "two":
            return new SomeEnum(2);
            break;
        case "three":
            return new SomeEnum(3);
            break;
        default: 
            return new SomeEnum(-1); // or zero or Integer.[MIN|MAX]_VALUE
            break;
      }
}

然后你可以随意使用SomeEnum。

有些模型不喜欢中间返回，所以，你可以在里面添加一个临时的SomeEnum并在最后返回它。

typeOf SomeEnum是enum

public SomeEnum returnAType(final String someString) {
     switch (someString.toLowerCase()) { //toLowerCase() if needed
        case "one":
            return SomeEnum.ENUM1;
            // break; // Normaly break; is unused, you can  remove it
        case "two":
            return SomeEnum.ENUM2;
        case "three":
            return SomeEnum.ENUM3;
        default: 
            return SomeEnum.DEFAULT_ENUM; 
      }
}

选择枚举类型时的好方法设计？

3 个答案: