C 语言中可以这样来定义枚举
enum color {
RED=0, GREEN, BLUE, YELLOW
} col;
关键字 enum 定义枚举，在定义枚举的同时，声明该枚举变量 col.
注意：C 语言中枚举成员的值是根据上下文自动加 1 的（GREEN = 1, BLUE = 2 等）。
C 语言中 switch 语句支持枚举类型
#include<stdio.h>
int main() {
enum color {
RED=0, GREEN, BLUE, YELLOW
} col;
int cl;
printf("0=red,1=green,2=blue,3=yellow. seclect:\n");
scanf("%d",&cl);
col=(enum color) cl;
switch(col) {
case RED:
printf("the color is red\n");
break;
case GREEN:
printf("the color is green\n");
break;
case BLUE:
printf("the color is blue\n");
break;
case YELLOW:
printf("the color is yellow\n");
break;
defalut:
printf("no this color\n");
break;
}
return 0;
}
那么，Java 里面的枚举与其类似，但是又不是完全一样。
Java 语言中定义枚举也是使用关键字 enum
public enum Color {
RED, GREEN, BLUE, YELLOW;
}
上述定义了一个枚举类型 Color（可以说是类，编译之后是 Color.class）.
上面的定义，还可以改成下面的这种形式
public enum Color {
RED(), GREEN(), BLUE(), YELLOW();
}
到这里你就会觉得迷茫（如果你是初学者的话），为什么这样子也可以？
其实，枚举的成员就是枚举对象，只不过他们是静态常量而已。
使用 javap 命令（javap 文件名<没有后缀.class>）可以反编译 class 文件，如下：
我们可以使用普通类来模拟枚举，下面定义一个 Color 类。
public class Color {
private static final Color RED = new Color();
private static final Color GREEN = new Color();
private static final Color BLUE = new Color();
private static final Color YELLOW = new Color();
}
对比一下，你就明白了。
如果按照这个逻辑，是否还可以为其添加另外的构造方法？答案是肯定的！
public enum Color {
RED("red color", 0), GREEN("green color", 1),
BLUE("blue color", 2), YELLOW("yellow color", 3);
Color(String name, int id) {
_name = name;
_id = id;
}
String _name;
int _id;
} 为 Color 声明了两个成员变量，并为其构造带参数的构造器。
如果你这样创建一个枚举
public enum Color {
RED("red color", 0), GREEN("green color", 1),
BLUE("blue color", 2), YELLOW("yellow color", 3);
}
编译器就会报错
The constructor EnumDemo.Color(String, int) is undefined 到此，你就可以明白，枚举和普通类基本一致（但是不完全一样）。
对于类来讲，最好将其成员变量私有化，然后，为成员变量提供 get、set 方法。
按照这个原则，可以进一步写好 enum Color.
public enum Color {
RED("red color", 0), GREEN("green color", 1),
BLUE("blue color", 2), YELLOW("yellow color", 3);
Color(String name, int id) {
_name = name;
_id = id;
}
private String _name;
private int _id;
public void setName(String name) {
_name = name;
}
public void setId(int id) {
_id = id;
}
public String getName() {
return _name;
}
public int getId() {
return _id;
}
}
但是，java 设计 enum 的目的是提供一组常量，方便用户设计。
如果我们冒然的提供 set 方法（外界可以改变其成员属性），好像是有点违背了设计的初衷。
那么，我们应该舍弃 set 方法，保留 get 方法。
public enum Color {
RED("red color", 0), GREEN("green color", 1),
BLUE("blue color", 2), YELLOW("yellow color", 3);
Color(String name, int id) {
_name = name;
_id = id;
}
private String _name;
private int _id;
public String getName() {
return _name;
}
public int getId() {
return _id;
}
}
普通类，我们可以将其实例化，那么，能否实例化枚举呢？
在回答这个问题之前，先来看看，编译之后的 Color.class 文件
public static enum Color {
RED("red color", 0), GREEN("green color", 1),
BLUE("blue color", 2), YELLOW("yellow color", 3);
private String _name;
private int _id;
private Color(String name, int id) {
this._name = name;
this._id = id;
}
public String getName() {
return this._name;
}
public int getId() {
return this._id;
}
}
可以看出，编译器淘气的为其构造方法加上了 private，那么也就是说，我们无法实例化枚举。
所有枚举类都继承了 Enum 类的方法，包括 toString 、equals、hashcode 等方法。
因为 equals、hashcode 方法是 final 的，所以不可以被枚举重写（只可以继承）。
但是，可以重写 toString 方法。
关于 Enum 源码，详见附录！
那么，使用 Java 的不同类来模拟一下枚举，大概是这个样子
package mark.demo;
import java.util.ArrayList;
import java.util.List;
public class Color {
private static final Color RED = new Color("red color", 0);
private static final Color GREEN = new Color("green color", 1);
private static final Color BLUE = new Color("blue color", 2);
private static final Color YELLOW = new Color("yellow color", 3);
private final String _name;
private final int _id;
private Color(String name, int id) {
_name = name;
_id = id;
}
public String getName() {
return _name;
}
public int getId() {
return _id;
}
public static List<Color> values() {
List<Color> list = new ArrayList<Color>();
list.add(RED);
list.add(GREEN);
list.add(BLUE);
list.add(YELLOW);
return list;
}
@Override
public String toString() {
return "the color _name=" + _name + ", _id=" + _id;
}
