java - 在 setter 中使用 switch 语句

Question

这可能是一个非常愚蠢的问题，但我想我应该尝试问一下!基本上问题是这样的:我可以在我的 setter 中使用 switch 语句吗？

这就是我正在做的事情:我创建了一个 Monster 类，其属性包括 healthPoints、描述、伤害和类型，其中 type 是一个枚举。在我的驱动程序中，我编写了几行代码，这些代码将从枚举值随机生成怪物类型，并且它将使用该类型创建一个新怪物。

问题是，当我显示怪物统计数据时，它显示生命值和伤害为 0，描述为空。当我尝试使用默认的 Monster 构造函数运行该程序时，它崩溃并显示 NullPointerException 错误。

我认为错误出在我的 setter 或构造函数中。每个 setter 内部都有一个开关盒，可根据随机生成的怪物类型设置一定数量的生命值、伤害和具体描述。我不确定在 setter 中使用 switch 语句是否可以，因为我以前从未真正需要这样做。

这是我的一些代码。首先，我的构造函数。

public Monster(int healthPoints, monsterType type, int damage, String description)
{
    setHealthPoints(healthPoints);
    setType(type);
    setDamage(damage);
    setDescription(description);
}

public Monster(monsterType type)
{
    setType(type);
}

下面是其中一位设置者。

public void setHealthPoints(int healthPoints)
{
    switch(type)
    {
        case DROW: 
            healthPoints = 30;
            break;
        case LICH:
            healthPoints = 40;
            break;
        case ORC:
            healthPoints = 20;
            break;
        case OWLBEAR:
            healthPoints = 20;
            break;
        case RUST_MONSTER:
            healthPoints = 10;
            break;
    }
    this.healthPoints = healthPoints;
}

下面是驱动程序中创建怪物的代码行。

int number = new Random().nextInt(monsterType.values().length);
        Monster monster = new Monster(monsterType.values ()[number]);

我希望根据生成的怪物类型来设置怪物的生命值、伤害和描述。我不确定这是否可以使用 setter 中的开关来完成，我觉得我的错误可能很明显，我只是没有看到它，因为我已经盯着它看了很长时间......或者，如果有其他或更简单的方法来执行此操作，请告诉我!感谢您花时间阅读；我试图让我的问题/问题变得彻底。

Answer 1

说明

是的，您可以在构造函数和方法中使用switch case。问题是您在 setType 之前调用 setHealthPoints，但第一个方法在其 switch 语句中使用 type:

setHealthPoints(healthPoints);
setType(type);

因此，当您访问 setHealthPoints 的 switch 时，变量 type 是未初始化，因此当前空。

如果 switch 语句的参数为 null，则该语句将抛出 NullPointerException。这样你就得到了NPE。

您可以通过首先执行 setType 来解决此问题。

---

游戏架构建议

您应该创建一个更易读的结构，也更易于维护，尤其易于扩展。

因此请考虑创建一个Monster接口(interface)或抽象类。之后创建明确的怪物作为子类。 Monster 类将包含所有怪物之间相同的一切，尝试从特定的怪物中抽象出来。怪物本身将只包含与其他怪物不同的东西。

例如，您可以使用某种这样的:

public abstract class Monster {
    private int mHealthPoints;
    private int mDamage;
    private String mDescription;

    public Monster(int healthPoints, int damage, String description) {
        this.mHealthPoints = healthPoints;
        this.mDamage = damage;
        this.mDescription = description;
    }

    public int getHealthPoints() {
        return this.mHealthPoints;
    }

    public int getDamage() {
        return this.mDamage;
    }

    public String getDescription() {
        return this.mDescription;
    }
}

然后你就有特定的怪物类别，例如

public class Orc extends Monster {
    private static int HEALTH = 20;
    private static int DAMAGE = 10;
    private static String DESCRIPTION = "Nasty orc.";

    public Orc() {
        super(Orc.HEALTH, Orc.DAMAGE, Orc.DESCRIPTION);
    }
}

您也不再需要 monsterType enum，因为您可以通过 monster instanceof Orc 进行区分。然而，对于真正的模块化设计，您不应该在特定的类上工作。相反，使用大量描述属性和能力的接口(interface)。

例如接口(interface):

CanAttack
IsAttackable
HasHealth
CanWalk
CanFly
CanCollide
...

您的游戏逻辑可能仅构建在这些接口(interface)上。例如 CanAttack 可能如下所示:

public interface CanAttack {
    void attack(IsAttackable target);
}

巨大的优势是您可以轻松扩展您的游戏。例如，通过创建具有任意能力组合的怪物:

public SuperFlyingPig extends Monster implements
        CanAttack, HasHealth, CanWalk, CanFly {
    ...
}

它会神奇地工作，不需要任何额外的编码工作，因为你的逻辑不会关心特定的怪物。它仅适用于界面。