最近做android开发，需要用到枚举值，这样可以连续赋值，我按之前c++那样书写，如下所示：
public enumColorSelect {
RED_BAGE= 0,
GREEN_BAGE,
BLUE_BAGE;
}
编译不过。
我将赋值语句修改了以后，如下所示：
public enumColorSelect {
RED_BAGE ,
GREEN_BAGE,
BLUE_BAGE;
}
编译通过。说明C++那样的赋值方法不适用java。所以，我需要弄清楚的是：
1. 在java平台上，如何初始化枚举值。
2.像上述那样的枚举类型ColorSelect，没有赋值，为什么switch(ColorSelect) 可以运行?它是通过字符串还是整数值来匹配枚举类型。
为了弄清楚上述问题，我自己就写了个示范程序，将该程序编译后，看看结果，是否可以找到答案。
一. 如何初始化枚举值
下面是我的示范程序：
自己定义的枚举类：
public enum ColorSelect {   //定义枚举类ColorSelect
RED_BAGE ,   //定义三个枚举对象
GREEN_BAGE,
BLUE_BAGE;
}
通过反编译，这段代码反编译后的程序是:
public final class ColorSelect extendsEnum
{public static ColorSelect valueOf(String s)  //公有函数，该方法通过字符串获取对应的ColorSelect 对象
{return (ColorSelect)Enum.valueOf(test/Enum/TestEnum$ColorSelect, s);
}public static ColorSelect[] values()  //公有函数该方法获取所有的ColorSelect对象
{
ColorSelect acolorselect[]= ENUM$VALUES; //ENUM$VALUES是ColorSelect数组，下面的代码会将其进行初始化
int i =acolorselect.length;
ColorSelect acolorselect1[]= newColorSelect[i];
System.arraycopy(acolorselect,0, acolorselect1, 0, i);returnacolorselect1;
}public static final ColorSelect BLUE_BAGE; //定义公共成员BLUE_BAGE，属于ColorSelect对象
private static final ColorSelect ENUM$VALUES[]; //定义私有成员ENUM$VALUES[]，属于ColorSelect数组
public static final ColorSelect GREEN_BAGE; //定义公共成员GREEN_BAGE，属于ColorSelect对象
public static final ColorSelect RED_BAGE;  //定义公共成员RED_BAGE，属于ColorSelect对象
static{//static里面这段代码，将上面定义的是三个公共成员ColorSelect对象进行初始化，然后将他们全部赋值给ENUM$VALUES
RED_BAGE = new ColorSelect("RED_BAGE", 0);  //初始化BLUE_BAGE
GREEN_BAGE = new ColorSelect("GREEN_BAGE", 1);  //初始化GREEN_BAGE
BLUE_BAGE = new ColorSelect("BLUE_BAGE", 2); //初始化BLUE_BAGE
ColorSelect acolorselect[] = new ColorSelect[3];
ColorSelect colorselect=RED_BAGE;
acolorselect[0] =colorselect;
ColorSelect colorselect1=GREEN_BAGE;
acolorselect[1] =colorselect1;
ColorSelect colorselect2=BLUE_BAGE;
acolorselect[2] =colorselect2;
ENUM$VALUES=acolorselect;
}private ColorSelect(String s, int i) //私有函数，调用父类进行初始化ColorSelect对象
{super(s, i);
}
}
从该反编译的代码看，有两个公有成员函数：
public static ColorSelect valueOf(String s);  该方法通过字符串获取对应的ColorSelect 对象
public static ColorSelect[] values();  该方法获取所有的ColorSelect 对象
这两种方法，在java里面可以直接调用。
下面的是ColorSelect的数据成员。
public static finalColorSelect BLUE_BAGE;private static finalColorSelect ENUM$VALUES[];public static finalColorSelect GREEN_BAGE;public static final ColorSelect RED_BAGE;
公有数据就是BLUE_BAGE，GREEN_BAGE，RED_BAGE，它们本身属性就是ColorSelect类。所以，从这里可以看到枚举类定义的成员变量也是类。后续的代码：
RED_BAGE = new ColorSelect("RED_BAGE", 0);
GREEN_BAGE= new ColorSelect("GREEN_BAGE", 1);
BLUE_BAGE= new ColorSelect("BLUE_BAGE", 2);
这三行相当于初始化这三个类，并且每个类分配唯一的序号，按定义时的顺序从0递增。我们在java代码，可以调用ColorSelect.BLUE_BAGE.ordinal()来得到对应的序号值。
通过以上分析，java枚举是一个类，不是语言本身实现的，而是编译器实现的，我们可以直接调用里面的方法。Enum 本身就是个普通的 class, 可以有很多自定义方法用来实现不同的功能。如果我们不自定义里面的方法，编译器就能初始化，默认顺序从0递增。我们也可以自定义方法，这样就能随便赋值。
下面是我们自定义的java枚举类型，可以赋值。
  public enumTemp {/*通过括号赋值,而且必须有带参构造器和一属性跟方法，否则编译出错
* 赋值必须是都赋值或都不赋值，不能一部分赋值一部分不赋值
* 如果不赋值则不能写构造器，赋值编译也出错*/absoluteZero(-459), freezing(32),boiling(212), paperBurns(451);private final intvalue;public intgetValue() {returnvalue;
}//构造器默认也只能是private, 从而保证构造函数只能在内部使用
Temp(intvalue) {this.value =value;
}
}
这就是一个枚举类，自定义方法来赋值。java不像C++那样简便，初始第一个值，后续值递增。赋值必须是都赋值或都不赋值，不能一部分赋值一部分不赋值。如果不赋值则不能写构造器，赋值编译也出错。
Temp temp = null;
Log.i("Temp##",temp.freezing.getValue()+"");
在主函数中，我们调用temp.freezing.getValue()，得到对应的值32。
如果大家感觉自定义枚举类麻烦，其实也可以用别的方法来代替自定义枚举类。如下所示：
public classColorSelect {private static final int  RED_BAGE = 1;private static final int  GREEN_BAGE = 3;private static final int  BLUE_BAGE = 5;
}
这种方法也比较方便。
二. 第一个疑问搞清楚了，我们现在要解决第二个问题。Switch到底通过字符串，还是整型来分辨枚举变量。
下面是java代码段：
ColorSelect test =ColorSelect.BLUE_BAGE;switch(test){caseRED_BAGE:
Log.i("TEST####1","a");break;caseGREEN_BAGE:
Log.i("TEST####2","b");break;caseBLUE_BAGE:
Log.i("TEST####3","c");break;default:
Log.i("TEST####4","d");
}
Log.i("TEST####ret", "e");
反编译后的代码：
{  //主函数
ColorSelect colorselect =ColorSelect.BLUE_BAGE;
ai= $SWITCH_TABLE$test$Enum$TestEnum$ColorSelect();  //调用子函数$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect()，返回数组赋值给ai
i = colorselect.ordinal();  //得到该枚举类型BLUE_BAGE的序号
ai[i]; //switch根据ai[i]值来进行判断
JVM INSTR tableswitch 1 3: default 56 //1 3是ai[i]的取值范围//1 73//2 84//3 95;
goto_L1 _L2 _L3 _L4
_L1:
Log.i("TEST####4", "d");
_L6:
Log.i("TEST####ret", "e");return;
_L2:
Log.i("TEST####1", "a");continue; /*Loop/switch isn't completed*/_L3:
Log.i("TEST####2", "b");continue; /*Loop/switch isn't completed*/_L4:
Log.i("TEST####3", "c");if(true) goto _L6; else goto_L5
_L5:
}private static int$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect[];
}//子函数
static int[] $SWITCH_TABLE$test$Enum$TestEnum$ColorSelect()  //{int ai[] =$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect;if(ai == null)
{
ai= new int[ColorSelect.values().length];try  //下面的代码，将每一个枚举类型的序号值作为数组ai的下标，然后赋一个整数值
{int i =ColorSelect.BLUE_BAGE.ordinal();
ai[i]= 3;
}catch(NoSuchFieldError nosuchfielderror2) { }try{int j =ColorSelect.GREEN_BAGE.ordinal();
ai[j]= 2;
}catch(NoSuchFieldError nosuchfielderror1) { }try{int k =ColorSelect.RED_BAGE.ordinal();
ai[k]= 1;
}catch(NoSuchFieldError nosuchfielderror) { }
$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect=ai;
}returnai;
}
子函数$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect()的功能：
通过int i = ColorSelect.BLUE_BAGE.ordinal()得到该类的唯一序号，作为数组下标,并且赋值给ai[i]。这样，每一个枚举类对应都有唯一的整数对应。然后返回数组ai[]。这个功能是编译器实现的。我感觉，子函数的功能有些多余，其实可以直接用之前初始化枚举类的时候的下标号，直接作为标识符也行，就不用再给每个枚举类重新赋整数值。
主函数里面，调用子函数$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect()，switch()里面的参数是ai[i]，根据这个整数值来判断分支。Java里面枚举值通过编译器给每个枚举类型赋整型数值，然后Switch通过识别这些整数来进行判断分支，这就解决了第二个疑问。
同时我们通过对比switch的java代码和反编译的代码，可以得到大概下面的结论。
1.每个标志位的"continue"说明该分支break。
2.最后一个分支的标志是if (true) goto _Lx，else goto _x。
同时我们通过对比switch的java代码和反编译的代码，可以得到大概下面的结论。
1.每个标志位的"continue"说明该分支break。
2.最后一个分支的标志是if (true) goto _Lx，else goto _x。
同时，还有些疑问，没弄明白？
我写了好几个switch的例子，反编译出来的代码有一个共同规律。
反编译代码1：
JVM INSTR tableswitch 1 3: default 56
//1 73//2 84//3 95;
goto _L1 _L2 _L3 _L4
反编译代码2：
JVM INSTR tableswitch 0 2: default 60
//0 77//1 88//2 99;
goto _L1 _L2 _L3 _L4
这两个，标明 1， 2，3相互之间数值都相差11。第二个也是。这个搞不懂？同时，这些数值代表什么？
如果以上哪些不对的地方，请大家指正。
(转自：http://blog.csdn.net/bage1988320/article/details/6690845)

今天遇到一个问题，就是设计了两个枚举，一个是状态枚举(EnumA)一个是动作枚举(EnumB)，状态枚举定义了当前状态的可以进行的操作，操作枚举定义了执行了此操作后的下一个状态。
具体代码如下：
public enum EnumA {
STATUS_A("STATUS_A", "状态A", EnumB.OPERATION_A),
STATUS_B("STATUS_B", "状态B", null);
private String                             code;
private String                             desc;
private List                        operation;
}
EnumA(String code, String desc, List operation) {
this.operation = operation;
this.code = code;
this.desc = desc;
}
public enum EnumB {
OPERATION_A("OPERATION_A", "操作1", EnumA.STATUS_B);
private String                             code;
private String                             desc;
private EnumA                              next;
}
EnumB(String code, String desc, EnumA next) {
this.next = next;
this.code = code;
this.desc = desc;
}
当我按照这种定义去声明枚举值常量时，编译器并没有错误提示。
但是执行的时候结果如下：
public static void main(String[] args) {
System.out.println(EnumB.OPERATION_A.getNext());
System.out.println(EnumA.STATUS_A.getOperation());
}
image.png
public static void main(String[] args) {
System.out.println(EnumA.STATUS_A.getOperation());
System.out.println(EnumB.OPERATION_A.getNext());
}
image.png
可以看出来，首先被使用到的枚举值中的内容是完整的。原因简单分析一下便容易明白，当第一个枚举值(例如是EnumA)被使用的时候，虚拟机查到这个EnumA的实例还没有加载，便调用构造函数去实例化。构造函数中需要EnumB的某个实例，所以虚拟机会调用EnumB的构造函数去实例化EnumB，但是此时EnumA还没有实例化完成，拿到的指针为NULL，所以EnumB中的类型为EnumA的属性便为NULL。
解决方法
对症下药的想法就是将两个枚举的关系在初始化层面解除耦合，但是带来的问题是两个枚举又需要使用对方的实例，什么时候将对方的实例填充进去呢？初步想法是当首先被调用的枚举实例化完成后将此枚举的实例填入另外一个枚举属性中。
那第二个问题便是如何让首先使用的枚举实例化后自动的开始填充动作呢？映入脑海的应该是代码块了，它是类加载的时候会自动执行的代码逻辑。所以是否可以采用在构造函数下方添加一个代码块来让枚举实例化(调用构造函数)后执行相应的代码呢？
具体代码如下：
public enum EnumA {
STATUS_A("STATUS_A", "状态A", EnumB.OPERATION_A),
STATUS_B("STATUS_B", "状态A", null);
private String code;
private String desc;
private EnumB  operation;
EnumA(String code, String desc, EnumB next) {
this.code = code;
this.desc = desc;
this.operation = next;
}
{
EnumB.OPERATION_A.setNext(STATUS_B);
}
}
但是添加了代码后，编译器明显的提示像是对我说：“小伙子想的太简单了”。
image.png
这段代码有一个警告和一个编译错误，他们的内容分别如下：
image.png
image.png
这里说明了，枚举实例是静态的，就是和静态成员变量(用static修饰的变量)是同一个级别的。但是他们的初始化又是利用构造函数才可以完成的，执行了构造函数则必然会执行代码块。因为实例化要一个一个执行，所以代码块执行的时候其他的某些枚举实例还没有创建，所以需要使用静态代码块来完成填充的动作。
所以正确的方式如下：但是并不是完美解决了，需要看文章最后一部分的说明
public enum EnumA {
STATUS_A("STATUS_A", "状态A", EnumB.OPERATION_A),
STATUS_B("STATUS_B", "状态A", null);
private String code;
private String desc;
private EnumB  operation;
static {
EnumB.OPERATION_A.setNext(STATUS_B);
}
EnumA(String code, String desc, EnumB next) {
this.code = code;
this.desc = desc;
this.operation = next;
}
}
枚举实例加载顺序
这里做了一个实验，可以观察到枚举实例在实例化时的执行顺序：
public enum EnumA {
STATUS_A("STATUS_A", "状态A", EnumB.OPERATION_A),
STATUS_B("STATUS_B", "状态A", null);
private String code;
private String desc;
private EnumB  operation;
static {
System.out.println("static:");
}
EnumA(String code, String desc, EnumB next) {
this.code = code;
this.desc = desc;
this.operation = next;
System.out.println("constructor:" + this);
}
{
System.out.println("init:" + this);
}
}
image.png
可见在实例化的时候，构造函数和代码块依次执行。当全部枚举实例都实例化完成后静态代码块才会执行，逻辑比较简单，毕竟枚举实例属于静态变量，当前的状态还是处于类级别初始化阶段，只不过初始化要用到具体对象的实例化逻辑，才会调用到构造函数和代码块，当全部枚举实例实例化完成后，类初始化完毕后便会执行静态代码块中的逻辑。
写在最后
这一点是在完成总结的时候想到的，因为上述方案只是在EnumA中进行了属性值的填充，但是它的前提是EnumA要优先在EnumB之前被调用，不然在EnumB实例化的时候会需要EnumA先实例化完成，但是填充逻辑是在EnumA中的，填充时又需要EnumB的实例，执行的话会报空指针。所以要保证枚举的加载顺序才行
解决方法
第一步：将没有填充逻辑的枚举中构造函数中的入参中去掉类型为另外一个枚举的变量，这样做才可以保证正常的初始化。
第二步：在没有填充逻辑的枚举中的静态代码块中调用一下有填充逻辑的枚举，这样就会触发实例化另外一个枚举的动作，并且执行填充逻辑。这样即使没有填充逻辑的枚举优先被调用，也可以获取到正常的值。
具体代码如下：
public enum EnumB {
OPERATION_A("OPERATION_A", "操作1");
private String code;
private String desc;
@Setter
private EnumA  next;
static {
EnumA init = EnumA.STATUS_A;
}
EnumB(String code, String desc) {
this.code = code;
this.desc = desc;
}
}

import java.util.Arrays;
/**
* 1. 定义一个数组 int[] iArr; // 这时数组还没有初始化,不能使用
* 2. 在定义时,初始一个数组 int iArr = new int[5]; //初始化为5个元素数组,为[0,0,0,0,0]
* 3. 在定义时初始化一个数组 int iArr2 = {1,2,3,4,5};
*    上面这种方式只能在定义时可以,假如int[] iArr; iArr = {1,2,3,4,5}; // 这样分两步不行
*
*/
public class TestArray
{
/**
* 可变参数的函数
* int ... args 这样的参数方式,表示可以传递任意多的参数给variableAgrs,
* 在variableAgrs函数中args当成数组对待
*/
public static void variableAgrs(int ... args)
{
System.out.println(args.length); //参数个数
int iLen = args.length;
for (int i=0;i
{
System.out.print(args[i]);
}
System.out.println("");
}
/**
* 创建一个简单的枚举
* 创建Spiciness后,指定的类似NOT这样的都是Spiciness的实例
* Spiciness实例自动具有一些方法,比如toString(),ordinal()
* Spiciness具有动态方法values();这个方法按照Spiciness中常量实例定义的顺序生成数组
*/
enum Spiciness
{
NOT,MILD,MEDIUM,HOT,FLAMING
}
public static void main(String[] args)
{
//数组初始化
int[] iArr = new int[5];   //5五个元素被初始化为[0,0,0,0,0]
System.out.println(Arrays.toString(iArr));
int[] iArr2 ;
//System.out.println(Arrays.toString(iArr2)); //编译不通过,数组需要初始化
//iArr2 = {1,2,3,4,5};编译不通过
iArr2 = new int[3];
System.out.println(Arrays.toString(iArr2));
//{1,2,3,4,5} 这种方式初始化数组,只能在定义时,比如
int[] iArr3 = {1,2,3,4,5};
System.out.println(Arrays.toString(iArr3));
//可变参数调用,可以传递0~任意多的参数
variableAgrs();//输出  0
variableAgrs(1); //输出 1 1
variableAgrs(1,2);//输出 2 12
variableAgrs(iArr3); //甚至,可以传递数组引用, 输出 5 12345
//枚举
Spiciness spiciness = Spiciness.HOT;
System.out.println(spiciness.toString()); //输出 HOT
System.out.println(spiciness.ordinal()); //输出 3
System.out.println(Arrays.toString(Spiciness.values())); //输出 [NOT, MILD, MEDIUM, HOT, FLAMING]
//枚举可在switch中使用
switch(spiciness)
{
case NOT:
{
System.out.println("Not");
break;
}
case MILD:
{
System.out.println("MILD");
break;
}
case MEDIUM:
{
System.out.println("MEDIUM");
break;
}
case HOT:
{
System.out.println("HOT");
break;
}
case FLAMING:
{
System.out.println("FLAMING");
break;
}
default:
{
System.out.println("default");
break;
}
}
}
}
赞 赏

在使用enum之前，需要先创建一个整型常量集，但枚举值并不会取值限定在这个常量集的范围内，因此，具有一定的风险，且较难使用。

枚举类型的创建,
public enum Spiciness{
    NOT,MILD,MEDIUM,HOT,FLAMING
}
创建枚举类型时编译器会自动添加一些特性，如会自动创建toString()方法，以便你可以很方便的显示某个enum实例的名字，除此之外，还会创建ordinal()方法，用于表示某个特定enum常量的声明顺序；还有static values()方法，按照enum常量的声明，产生由这些常量构成的数组：

实例如下：
public class SimpleEnumUse {
public enum Spiciness{
	NOT,MILD,MEDIUM,HOT,FLAMING
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Spiciness hotHot= Spiciness.MEDIUM;
		System.out.println(hotHot);
		for(Spiciness s:Spiciness.values())          //value()方法用来产生顺序数组
			System.out.println(s+",ordinal "+s.ordinal());//ordinal()方法用来声明顺序
	}
}
/* Output:
NOT,ordinal 0
MILD,ordinal 1
MEDIUM,ordinal 2
HOT,ordinal 3
*/
由此可见，可以把enum当作其他类来处理。事实上enum确实是类，而且可以用有限的可能值集合配合switch使用。
如下，
import thinkinginjava5_.SimpleEnumUse.Spiciness;
class Burrito{
	Spiciness degree;
	public Burrito(Spiciness degree) {
		// TODO Auto-generated constructor stub
		this.degree=degree;
	}
	public void describe(){
		System.out.print("This burrito is ");
		switch(degree){
		case NOT:System.out.println("not spicy at all.");
			break;
		case MILD:
		case MEDIUM:System.out.println("a little hot");
		break;
		case HOT:
		case FLAMING:System.out.println("maybe too hot");
		break;
		}
	}
}
public class SimpleEnumUse {
public enum Spiciness{
	NOT,MILD,MEDIUM,HOT,FLAMING
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub		
		Burrito plain=new Burrito(Spiciness.NOT),
		greenChile=new Burrito(Spiciness.MEDIUM),
		jalapeno=new Burrito(Spiciness.HOT);
		plain.describe();
		greenChile.describe();
		jalapeno.describe();
		
	}
}
/*Output 
This burrito is not spicy at all.
This burrito is a little hot
This burrito is maybe too hot
 */