4

我遇到了一个需要做出设计决定的案例（与其说是程序本身，不如说是为了了解其他人在这种情况下所做的事情，最好将其视为 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”类，该类有一个带有开关处理的方法。（这意味着程序员可以更改计算而不是故意的）。但是，如果我想稍后将枚举移动到文件中，这将导致更少的问题。但是，我质疑这是否会破坏封装，如果这只是枚举的责任。

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

--

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

4

3 回答 3

3

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

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

于 2013-05-14T13:55:55.690 回答
1

您可以将多个参数传递和存储到 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;
        }
    }

    ...
}
于 2013-05-14T13:50:31.287 回答
1

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

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

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

这听起来像是第一个选项的扩展：现在调用者负责整理 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;
    }
}
于 2013-05-14T13:50:58.447 回答