不同的枚举方法参数

Question

我遇到了一个需要做出设计决策的案例（与其说是程序本身，不如说是为了了解其他人在这种情况下做了什么，最好把它看作是是一个 API）。我有一个枚举类：

public enum Type
{

    CAPTAIN(2),  // Only Use CalcMorale never other
    LEADER(5),   // Only use CalcMorale never other
    PARTIER(80); // Only use CalcMorale2 never other

    int calcMorale(int inMorale)
    {
        return inMorale * (100 + morale) / 100;
    }

    int calcMorale2(int inMorale, int teamCount)
    {
        return inMorale + morale * teamCount;
    }

    int morale;

    private Type(int aMor)
    {
        morale = aMor;
    }

}

有一个类 Character 持有这些枚举之一，也是传入参数的那个。

评论的问题是我只希望某些枚举使用枚举类中的某些方法。领导者增加了 5% 的团队士气，但党员为该党内的每个成员增加了 80%，因此需要另一个参数。我可以通过几种方式解决问题，但想知道社区对如何解决问题的普遍共识。

我可以：

让程序员有责任调用正确的方法。 （这对我来说听起来不对）。

给每个枚举它自己的函数版本。 （这会产生一个巨大的文件，我会重复很多代码）。

将责任留给“Character”类，该类有一个带有开关的方法来处理这个。 （这意味着程序员可以更改计算而不是故意的）。但是，如果我想稍后将枚举移动到文件中，这将导致更少的问题。但是我质疑这是否会破坏封装，如果这只是枚举的责任。

使类型成为一个类并通过匿名内部类定义方法。在这种情况下，类将添加到地图中，而不是在枚举类中使用 getByName()。

--

你认为什么最合适？ （我更喜欢我的类尽可能地独立，就像我使用 API 一样（它不会），你的建议会如何/会根据枚举的数量受到影响？那我想要的情况呢？能够同时使用这两种方法的枚举？语言是 Java。

Answer 1

正如您所说，您必须考虑您的应用程序将如何处理此问题。如果您希望枚举类自己处理这个问题，您将需要某种条件和某种形式的重载（这意味着开发人员将负责调用正确的方法。

但是，您可以强制开发人员始终发送 teamcount：

public enum Type {
    CAPTAIN(2),
    LEADER(5),
    PARTIER(80);

    private final int morale;

    private Type(int m){
        morale = m;
    }

    public int getMorale(int inMorale) {
         return getMorale (inMorale, 0);
    }

    public int getMorale(int inMorale, int teamCount) {
        switch (this) {
            case CAPTAIN:       
            case LEADER:
                return inMorale * (100 + morale) / 100;
            case PARTIER:
                return inMorale + morale * teamCount;
        }
        return 0;
    }
}

编辑：将开关更改为“this”

Answer 2

您可以将多个参数传递和存储到 Enum 值：

public enum Type
{

    CAPTAIN(2, true),  // Only Use CalcMorale never other
    LEADER(5, true),   // Only use CalcMorale never other
    PARTIER(80, false); // Only use CalcMorale2 never other
    ...

    int morale;
    boolean useFirstMethod;

    ...

    int calcMorale(int inMorale, int teamCount)
    {
        if (useFirstMethod) {
            return inMorale * (100 + morale) / 100;
        } else {
            return inMorale + morale * teamCount;
        }
    }

    ...
}

Answer 3

让程序员有责任调用正确的方法。 （这 对我来说听起来不对）。

你是对的，这不是最佳解决方案。

给每个枚举它自己的函数版本。 （这将使 大文件，我会重复很多代码）

这听起来像是第一个选项的扩展：现在调用者负责整理 n 个方法中的哪一个来调用 n 个 enum 值。

考虑继承方法而不是enums：

calcMorale和calcMorale2方法很相似，可以在一个接口中组合：

public interface Type
{
    int calcMorale(int inMorale);
}

这个abstract 类可以定义你常用的calcMorale 功能（其他人会在必要时覆盖它）。

public abstract class AbstractType
{
    protected final int morale;

    public AbstractType(int morale)
    {
        this.morale = morale;
    }

    int calcMorale(int inMorale)
    {
        return inMorale * (100 + morale) / 100;
    }
}

Captain 和 Leader 直接从 AbstractType 扩展

public class Captain extends AbstractType
{
    public Captain()
    {
        super(2);
    }
}

public class Leader extends AbstractType
{
    public Leader()
    {
        super(5);
    }
}

但是Partier 覆盖了calcMorale 方法（第二个参数作为构造函数参数传递）

public class Partier extends AbstractType
{
    private final int teamCount;

    public Partier(int teamCount)
    {
        super(80);
        this.teamCount = teamCount;
    }

    @Override
    public int calcMorale(int inMorale)
    {
        return inMorale + morale * teamCount;
    }
}