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;
    }

}

有一个类字符，它包含其中一个枚举，也是传递参数的一个。

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

我可以：

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

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

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

Make Type一个类，并通过匿名内部类定义方法。在这种情况下，类将添加到地图中，而不是在枚举类中具有getByName（）。

-

您认为最合适的是什么？（我更喜欢我的课程尽可能自我依赖，就好像我使用的是API（它不会），以及你的建议会如何/会根据枚举量受到影响？那么我想要的情况怎么样？一个能够使用这两种方法的枚举？语言是Java。

Answer 1

就像你说的那样，你必须考虑你的应用程序将如何处理这个问题。如果你想让enum类自己处理它，你将需要某种条件和某种形式的重载（这意味着开发人员将负责调用正确的方法。

但是，您可以强制开发人员始终发送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;
    }
}

编辑：将切换更改为'此'

Answer 2

您可以将多个参数传递并存储到枚举值：

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值。

而不是enum，考虑一种继承方法：

方法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;
    }
}

不同的Enum方法参数

3 个答案: