Question

我整个上午都在查看有关枚举的教程和文章，而我只是试图了解他们如何帮助我。

这是我目前的问题：

我正在制作一个程序，帮助管理玩家在视频游戏中收集的项目。玩家拥有的空间量有限。每个角色只有88个插槽。玩家收集的物品大小不一。

有九种类型的物品：

靴子（总是4号）
     腰带（总是2号）

头盔（总是4号）

响铃（总是1号）

护身符（总是1号）

手套（总是4号）

防弹衣（总是6号）

武器（可以在2到8之间）

盾牌（可以在4号和8号之间）

要确定给定武器或盾牌的大小，有一个包含所有不同名称和大小的表格。例如，名称Kite Shield对应的大小为6.所有这些数据都在HashTable中，名称是键，它占用的空间量是值。试想一下这个表已经在我的程序中了。 HashTable接受一个String名称（例如＆＃34; Long Bow＆＃34;以及对应的值为8）并返回一个Integer大小值。

public class Item
{
    /** Name is the first part of the item. Ex. Long Bow */
    private String name;

    /**
     * Defines what an item object is.
     * @param name of item.
     */
    public Item(String name)
    {
        this.name = name;
    }

    public int getItemSize()
    {
        // TODO: Algorithm here using Enums to determine size of a given item.
    }

    public String getName()
    {
        return name;
    }
}

这是我为项目类型制作的枚举，但我无法看到它如何有用。

// This is where I need help ↓
public enum types
{
    HELM, AMULET, WEAPON, BODY_ARMOR, SHIELD, RING, GLOVES, BELT, BOOTS;

    // How do I use this enum to help me determine size?
}

如何在此处使用枚举以避免使用Strings和String.equals（）？谢谢！

Answer 1

Java中的枚举只是一个具有多个final属性且具有相同类实例的类的合成糖。

话虽如此，您不能在枚举中包含变量项，这意味着您的weapon和shield类型需要进行一些调整。

这就是我为你所做的：

enum ItemType {
    BOOTS (4),
    BELT(2),
    HELM(4),
    RING(1),
    AMULET(1),
    GLOVES(4),
    BODY_ARMOUR(6),
    WEAPON_2(2),
    //... other ones here
    WEAPON_8(8),
    SHIELD_4(4),
    //... other ones here
    SHIELD_8(8);

    private int size;

    ItemType(int size) {
        this.size = size;
    }

    public int getSize() {
        return size;
    }
}

唯一的细节是，您应该通过WEAPON_2，WEAPON_3等方式传播您的武器，以便能够在枚举中表示它。同样适用于shield。

这是running example。

为了将其整合到您的游戏中，我们假设您的Item课程如下：

public class Item {
    private String name;
    private ItemType type;

    public Item(String name, ItemType type) {
        this.name = name;
        this.type = type;
    }

    // getters and setters and anything else...
}

然后你实例化它：

Item sword = new Item("Excalibur", ItemType.WEAPON_4);
Item shield = new Item("Dragon Shield", ItemType.SHIELD_8);

Answer 2

您可以做的第一件事就是为types分配一个ItemType（BTW，我建议使用更好的名称，例如Item）。

public class Item {
    private final ItemType myType;
    private final String name;
    private final int size;

    public Item(ItemType myType, String name, int size) {
        this.myType = myType;
        this.name = name;
        if ((myType.getMinSize() > size) ||
                (myType.getMaxSize() < size)) {
            throw new IllegalArgumentException(); // or something else, whatever you want
        }
        this.size = size;
    }

    // various getters and other important stuff
}

您需要保留name字段，因为每个Item有多个ItemType，并且它们具有不同的name s（以及尺寸，并且可能是，其他属性）。

每个人Item必须具有自己的尺寸，因为它们可以变化。该大小属于Item类，因为它是实际Item的属性。但是你可以在枚举上加上最小值和最大值，只是为了进行健全性检查。

public enum ItemType {
    HELM(4, 4), AMULET(1, 1), WEAPON(2, 8), BODY_ARMOR(6, 6), SHIELD(4, 8), RING(1, 1), GLOVES(4, 4), BELT(2, 2), BOOTS(4, 4);

    private final int minSize;
    private final int maxSize;

    public ItemType(int minSize, int maxSize) {
        this.minSize = minSize;
        this.maxSize = maxSize;
    }

    public int getMinSize() {
        return minSize;
    }

    public int getMaxSize() {
        return maxSize;
    }

其他用途可能会随着您的使用而出现，但只是为了能够针对一组已知值检查ItemType而不是进行字符串检查是一种胜利。 }

Answer 3

我认为这个类更有用，具有最小/最大值。目前尚不清楚您打算如何使用可变大小的类型。

public enum Types {

HELM(4, 4),
AMULET(1, 1), 
WEAPON(2, 8), 
BODY_ARMOR(6, 6), 
SHIELD(4, 8), 
RING(1, 1), 
GLOVES(4, 4), 
BELT(2, 2), 
BOOTS(4, 4);

private final int minSize;
private final int maxSize;
private Types(int minSize, int maxSize) {
    this.minSize = minSize;
    this.maxSize = maxSize;
}

public int getMinSize() {
    return minSize;
}
public int getMaxSize() {
    return maxSize;
}

}

然后相应地使用Types.WEAPON.getMinSize（） - 或 - Types.WEAPON.getMaxSize（）。

Answer 4

您可以在Enum中存储尺寸项目。对于像武器和盾牌这样的物品，你已经有了HashMap，所以我们只需将它留在枚举中。

如果size的值为0（WEAPON就是这种情况），我们使用HashMap。

public enum ItemType {
    HELM(4),
    AMULET(1),
    WEAPON(),
    BODY_ARMOR(6);

    private int itemSize;

    ItemType() {

    }

    ItemType(int itemSize) {
        this.itemSize = itemSize;
    }

    public int getItemSize() {
        return itemSize;
    }
}

现在，您可以在Item类中实现它。

public class Item
{
    /** Name is the first part of the item. Ex. Long Bow */
    private String name;

    private ItemType type;
    /**
     * Defines what an item object is.
     * @param name of item.
     */
    public Item(ItemType type, String name)
    {
        this.type = type;
        this.name = name;
    }

    public int getItemSize()
    {
        int size = type.getItemSize();
        if (size == 0)
            size = Constants.HASH_MAP.get(name);
        return size;
    }

    public String getName()
    {
        return name;
    }

    public ItemType getType() {
        return type;
    }
}

像这样创建你的Item类

Item longBow = new Item(ItemType.WEAPON, "Long Bow");

Answer 5

我喜欢枚举。他们为开发人员节省了大量不必要的工作。而不是这样做：

class Foo{
    public static final Foo BAR1 = new Foo(4);
    public static final Foo BAR2 = new Foo(24);
    private Foo(int i){
        ...
    }
}

开发人员可以这样做：

enum Foo{
    BAR1(4), BAR2(24);
    private Foo(int i){
        ...
    }
}

使用一堆有用的方法，例如values()，valueOf()等

根据您的情况，如果某个项目可以是两种尺寸之间的一种尺寸，我会在构造函数中创建minSize和maxSize。

public enum WeaponType{
    BOOTS(4, 4),
    BELT(2, 2),
    HELM(4, 4),
    RING(1, 1),
    AMULET(1, 1),
    GLOVES(4, 4),
    BODY_ARMOR(6, 6),
    WEAPON(2, 8),
    SHIELD(4, 8);
    private int minSize, maxSize;
    private Weapon(int minSize, int maxSize){
        this.minSize=minSize;
        this.maxSize=maxSize;
    }
    public int getMinSize(){
        return minSize;
    }
    public int getMaxSize(){
        return maxSize;
    }
}

我不知道你的具体情况和需求，但是关于minSize和maxSize，或只是大量的WEAPON_和大量的SHIELD_，这将是一个偏好的问题。你可以做任何你认为对你的具体情况更好的事情。

现在，您的Item类可以包含WeaponType变量：

WeaponType wp;

然后使用项目中的getSize方法：

public int getSize(){
    int min = wp.getMinimumSize();
    int max = wp.getMaximumSize();
    //Do whatever with those
}

如何在这个项目中使用枚举？

5 个答案: