Java中的类c枚举

enum {
  ANIMAL_CAT = 0,
  ANIMAL_RAT,
  ANIMAL_BAT, ...
  NUM_ANIMALS
};
Animal animals[NUM_ANIMALS];
animals[ANIMAL_CAT].mNumLegs = 4;
animals[ANIMAL_RAT].mNumLegs = 4; ...

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

"Classic" 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

为什么不这样简单:

public enum Animal {
    CAT(4), RAT(4), BAT(4), CHICKEN(2), ..., ANT(6), SPIDER(8);
    // A simple attribute, like any other java class.
    // Final to ensure it will never change.
    private final int legs;
    // Note that this constructor is private.
    private Animal(int legs) {
        this.legs = legs;
    }
    // A method, like any other class.
    public int getLegs() {
        return legs;
    }
}

使用它:

// How to get all the animals in the enum.
Animal[] animals = Animal.values();
// How to get the number of animals.
int numAnimals = animals.length;
// How to get the number of legs of some animal.
int howManyLegsHaveTheAnt = Animal.ANT.getLegs();
int howManyLegsHaveTheFirstAnimal = animals[0].getLegs();
// How to get the name of a given animal.
String theFirstAnimalName = animals[0].name(); // Will return "CAT".
// How to get the position in the enum of some animal.
int antPositionInTheEnum = Animal.ANT.ordinal();
// How to get an animal given its name.
Animal rat = Enum.valueOf(Animal.class, "RAT");
Animal someAnimal = Enum.valueOf(Animal.class, animalName);

简单的回答:不，Java没有类似c的枚举。虽然在java中也可以通过下面的一系列语句来实现:

public static final int GREEN = 1;
public static final int RED   = 2;
public static final int BLUE  = 3;

Java枚举是不同的

在您的情况下，使用枚举不是一个好主意。枚举本质上是不可变的东西，是一个固定的集合，在这个集合中不能产生新的元素，也不能破坏现有的元素。工作日、月份和纸牌套装都是枚举的好例子，现有的集合是固定不变的，永远不会创建新元素，也不会破坏现有元素。动物类型、音乐类型、贴图设置等都不遵循这些规则。

最好的方法是最明显的:定义一个接口或抽象类Animal。并将所有动物类型定义为一个亚型。

开关和goto一样邪恶，它们很简单，很容易使用，看起来很无辜，但最终会把你的代码转换成意大利面条丛林。不要使用您想要的开关，而是使用多态性。即:

// Don't:
public class SomeClass {
    public void myMethod() {
        switch (animal.id) {
            case TYPE_CAT:
                doSomethingThatCatDoes();
                doSomethingElse();
                anotherThing();
                break;
            case TYPE_DOG:
                bark();
                doSomethingThatDogDoes();
                otherThing();
                break;
        }
    }
}

// Do:
public interface Animal {
    public void myMethodAction();
    // Other methods.
}
public class Cat implements Animal {
    @Override
    public void myMethodAction() {
        doSomethingThatCatDoes();
        doSomethingElse();
        anotherThing();
    }
}
public class Dog implements Animal {
    @Override
    public void myMethodAction() {
        bark();
        doSomethingThatDogDoes();
        otherThing();
    }
}
public class SomeClass {
    public void myMethod() {
        animal.myMethodAction();
    }
}

当您这样做时，代码往往会变得更大，但这并不意味着更复杂。相反，它变得更好地组织，因为SomeClass不再需要知道确切的动物类型，每种动物类型的特定逻辑都在一个地方，如果您需要改变动物的行为，您不需要搜索和改变很多非常遥远的地方。此外，添加新的动物类型变得更加容易。正如你应该看到的，你的项目变得更加灵活，以适应未来的变化(也就是说，更容易改变，更难破坏)。

您应该注意到我没有使用显式id。避免id，因为它们是邪恶的，你已经有了它们的隐含意义。每个对象都有一个唯一的内存地址，这个内存地址就是id。那么public int mType;场就变成了public Class<? extends Animal> mType;场。如果您确实需要这些id，请尽量缩短它们的使用时间，并且尽量少使用它们。这样做的原因是为了更好地使用OO(我将在下面解释)。

另外，你的TypeInfo只是一堆公共属性。求你了，千万千万千万别想这么做。在OO中，公共属性就像goto和switch一样令人讨厌，它们肯定会以100%的概率破坏你的项目。相反，无论你做什么需要处理字段，都要放入TypeInfo类并将字段设为私有。这并不意味着用无脑的getter和setter来替换公共属性，而是把你的业务逻辑放在那里。

我强烈建议你深入学习一些OO。特别是真正的封装(有些人说添加一堆脑残的getter和setter是可以的，但事实并非如此，这不是真正的封装)。研究多态性，不仅仅是它是什么以及它是如何工作的，而是如何使用它以及为什么使用它。最重要的是，学习内聚和耦合，使类有意义，相当独立，可重用和灵活。