我正试图在 C++ 中找到一个 Java 等价物，以提供以下便利:

enum {
  ANIMAL_CAT = 0,
  ANIMAL_RAT,
  ANIMAL_BAT, ...
  NUM_ANIMALS
};

Animal animals[NUM_ANIMALS];

animals[ANIMAL_CAT].mNumLegs = 4;
animals[ANIMAL_RAT].mNumLegs = 4; ...

我知道这不是世界上最漂亮的东西，但我可以在枚举中的任何地方添加一个新的 ANIMAL_xxx，并且以下所有条目都会自动调整。在 Java 中是否有一种干净的方法来执行此操作？

感谢您的回复，但我可能已经暗示了比我预期的更简单。

我正在开发一款游戏，其中有物理、AI 引擎等。我正在尝试整合每种类型实体所需的所有信息(有些只有物理表现，而有些则有物理)和 AI 等...)，以便我可以轻松添加/修改类型(因此，动物是一个不好的例子，因为我可能需要岩石、植物等...)。

我正在使用一个类来存储类型信息，而其他类依赖于该类来查找属性(维度、位图索引、hasAi 等...)最后，我试图清理类似于以下内容，同时允许我轻松添加新类型:

class UnitTypeInfo {
  UnitTypeInfo() {
    mTypes = new TypeInfo[NUM_TYPES];

    // and allocate...

    // initialize TypeInfos here
    mTypes[TYPE_CAT].mType = TYPE_CAT;
    mTypes[TYPE_CAT].mMass = 10.0f;
    mTypes[TYPE_CAT] ...

    mTypes[TYPE_ROCK].mType = TYPE_ROCK;
    ...
  }

  public class TypeInfo {
    public int mType;
    public int mRawResourceHandle;
    public float mMass;
    public Vector2d mDimensions;
    public float mHealth;
    public boolean mHasAi;
    ...
  }

  public static final int TYPE_CAT = 0;
  public static final int TYPE_ROCK = 1;
  public static final int TYPE_TREE = 2; ...
  public static final int NUM_TYPES = ???; // the last TYPE_ + 1

  public TypeInfo mTypes[];
}

现在，这似乎是某种 XML 实现可能是“正确”的事情，但我不确定如何去做(Java 新手)。无论如何，其他类可以轻松地使用 unitTypeInfo.mTypes[UnitTypeInfo.TYPE_CAT].mMass(实例化)来查找猫的质量。但是，如果我想在 TYPE_CAT 定义下添加一个 TYPE_DOG，我必须更新它下面的所有内容(我知道这很懒，但让我们假设还有更多类型。)

枚举在 C++ 中为这个问题提供了一个简单的解决方案，但在 Java 中，我现在能想到的最简单的解决方案需要类似这样的东西:unitTypeInfo.mTypes[UnitTypeInfo.mTypeEnum.TYPE_CAT.ordinal()].mMass - 同时我想这并不比我已经很糟糕的解决方案差多少，它确实增加了更多的间接和实际的方法调用(大多数来源似乎不鼓励的方法)。 p>

还有一件事是我希望能够调用一个开关(类型)，所以这也可能会限制可能的解决方案。

无论如何，我开始觉得必须有更好的解决方案来解决整个问题。有什么建议吗？

最佳答案

“经典”java 总是使用“static final int ANIMAL_CAT = 0;”在这种情况下。

JDK 1.5 引入了“类型安全的枚举”:

http://www.javapractices.com/topic/TopicAction.do?Id=1

您现在可以这样做(一种非常常见的做法):

enum Quark {
    /*
    * These are called "enum constants".
    * An enum type has no instances other than those defined by its
    * enum constants. They are implicitly "public static final".
    * Each enum constant corresponds to a call to a constructor.
    * When no args follow an enum constant, then the no-argument constructor
    * is used to create the corresponding object.
    */
    UP,
    DOWN,
    CHARM,
    STRANGE,
    BOTTOM,
    TOP
  }

或者你可以这样做:

/**
  * Example 2 - adding a constructor to an enum.
  *
  * If no constructor is added, then the usual default constructor
  * is created by the system, and declarations of the
  * enum constants will correspond to calling this default constructor.
  */
  public enum Lepton {
    //each constant implicity calls a constructor :
    ELECTRON(-1, 1.0E-31),
    NEUTRINO(0, 0.0);

    /* 
    * This constructor is private.
    * Legal to declare a non-private constructor, but not legal
    * to use such a constructor outside the enum.
    * Can never use "new" with any enum, even inside the enum 
    * class itself.
    */
    private Lepton(int aCharge, double aMass){
      //cannot call super ctor here
      //calls to "this" ctors allowed
      fCharge = aCharge;
      fMass = aMass;
    }
    final int getCharge() {
      return fCharge;
    }
    final double getMass() {
      return fMass;
    }
    private final int fCharge;
    private final double fMass;
  }

官方文档如下:

http://docs.oracle.com/javase/1.5.0/docs/guide/language/enums.html

关于java - Java 中类似 C 的枚举，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8708077/