1、枚举类型
1.1.含义：如果一个变量只有几种可能的值，则可以定义为枚举类型。
例如enum Color{red,yellow,blue,white,black};声明了一个枚举类型
然后可以用此类型来定义变量，如enum Color color1，color2
枚举类型 枚举变量
1.2.特点
（1） 枚举变量和其它数值型不同，它们只限于花括号中制定的值之一。
（2）枚举中的每一个元素代表一个整数，默认0，1,2,3，。。
（3）赋值：red = 9；错。enum Color{red = 5,yellow = 4,blue = 4,white =2,black =1}正确。
（4）枚举元素的比较是按照其在初始化时指定的整数来进行比较的。
在枚举类型中，可以添加构造方法，但是规定构造方法必须为private修饰符所修饰，举个例子说明构造方法的使用方法：
2、枚举类型中的成员方法
枚举类型有很多的成员方法，可以将枚举类型看做是一个类，它集成于java.lang.Enum类。它具有以下方法：
下面以列子说用这几个方法的使用方法：
1 public class ShowEnum { 2 enum Constants2{ 3 A,B,C ; //可以没有分号,将常量放在枚举类型中 4 } 5 //定以比较枚举类型的方法，参数为枚举类型 6 public static void compare(Constants2 c){ 7 //根据values（）方法返回的数组做循环操作 8 for (int i = 0; i < Constants2.values().length;i++){ 9 //将比较结果返回 10 System.out.println(c+"与"+Constants2.values()[i]+"的比较结果:"+c.compareTo(Constants2.values()[i])); 11 } 12 } 13 public static void main(String[] args) { 14 //调用compare方法 15 compare(Constants2.valueOf("B")); 16 System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); 17 //循环有values返回的数组 18 for(int i = 0; i <Constants2.values().length;i++){ 19 //将枚举成员变量打印 20 System.out.println("枚举成员变量为："+Constants2.values()[i]); 21 } 22 System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); 23 for(int i = 0;i <Constants2.values().length;i++){ 24 // 25 System.out.println(Constants2.values()[i]+"在枚举类型中的索引位置为："+Constants2.values()[i].ordinal()); 26 } 27 } 28 29 }
运行结果：
B与A的比较结果:1
B与B的比较结果:0
B与C的比较结果:-1
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
枚举成员变量为：A
枚举成员变量为：B
枚举成员变量为：C
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A在枚举类型中的索引位置为：0
B在枚举类型中的索引位置为：1
C在枚举类型中的索引位置为：2
3、枚举类型中的构造方法
例：
1 public class EnumlndexTest { 2 enum Constants2 { 3 Constants_A("枚举成员A"), 4 Constants_B("枚举成员B"), 5 Constants_C("枚举成员C"), 6 Constants_D(3); 7 private String description; 8 private int i = 4; 9 10 private Constants2() { 11 12 } 13 14 private Constants2(String description){ 15 this.description = description; 16 } 17 18 private Constants2(int i) { 19 this.i = this.i + i; 20 } 21 22 public String getDescription() { 23 return description; 24 } 25 26 public int geti() { 27 return i; 28 } 29 30 31 } 32 public static void main(String[] args) { 33 for(int i = 0;i < Constants2.values().length;i++){ 34 System.out.println(Constants2.values()[i]+"调用getDescription()方法为："+Constants2.values()[i].getDescription()); 35 } 36 System.out.println(Constants2.valueOf("Constants_D")+"调用geti() 方法为："+Constants2.valueOf("Constants_D").geti()); 37 } 38 }
运行结果：
Constants_A调用getDescription()方法为：枚举成员A
Constants_B调用getDescription()方法为：枚举成员B
Constants_C调用getDescription()方法为：枚举成员C
Constants_D调用getDescription()方法为：null
Constants_D调用geti() 方法为：7
分析：将枚举类型中的构造方法设置为private，防止客户代码实例化一个枚举对象
上述代码中的getDescription()方法也可以放在接口中，如下代码：
在项目中创建d接口和枚举类型的AnyEnum类，在枚举类型AnyEnum类中实现带方法的接口，使每个枚举类型成员实现该接口中的方法。
1 package com.lzw; 2 import static java.lang.System.*; 3 interface d { 4 public String getDescription(); 5 6 public int getI(); 7 } 8 9 public enum AnyEnum implements d { 10 Constants_A { // 可以在枚举类型成员内部设置方法 11 public String getDescription() { 12 return ("我是枚举成员A"); 13 } 14 15 public int getI() { 16 return i; 17 } 18 }, 19 Constants_B { 20 public String getDescription() { 21 return ("我是枚举成员B"); 22 } 23 24 public int getI() { 25 return i; 26 } 27 }, 28 Constants_C { 29 public String getDescription() { 30 return ("我是枚举成员C"); 31 } 32 33 public int getI() { 34 return i; 35 } 36 }, 37 Constants_D { 38 public String getDescription() { 39 return ("我是枚举成员D"); 40 } 41 42 public int getI() { 43 return i; 44 } 45 }; 46 private static int i = 5; 47 48 public static void main(String[] args) { 49 for (int i = 0; i < AnyEnum.values().length; i++) { 50 out.println(AnyEnum.values()[i] + "调用getDescription()方法为：" 51 + AnyEnum.values()[i].getDescription()); 52 out.println(AnyEnum.values()[i] + "调用getI()方法为：" 53 + AnyEnum.values()[i].getI()); 54 } 55 } 56 }
运行结果：
Constants_A调用getDescription()方法为：我是枚举成员A
Constants_A调用getI()方法为：5
Constants_B调用getDescription()方法为：我是枚举成员B
Constants_B调用getI()方法为：5
Constants_C调用getDescription()方法为：我是枚举成员C
Constants_C调用getI()方法为：5
Constants_D调用getDescription()方法为：我是枚举成员D
Constants_D调用getI()方法为：5
4、使用枚举类型设置常量
通常在接口中设置常量，并且该常量不能被修改。因为在接口中定义常量时，该常量被修饰为static和final类型。在调用时不能检测参数的类型，而枚举类型定义的常量参数在调用时可以检测参数的类型。
以下面例子说用枚举类型与与接口定义常量的区别:
1 interface Constants { // 将常量放置在接口中 2 public static final int Constants_A = 1; 3 public static final int Constants_B = 12; 4 } 5 6 public class ConstantsTest { 7 enum Constants2 { // 将常量放置在枚举类型中 8 Constants_A, Constants_B 9 } 10 11 // 使用接口定义常量 12 public static void doit(int c) { // 定义一个方法，这里的参数为int型 13 switch (c) { // 根据常量的值做不同操作 14 case Constants.Constants_A: 15 System.out.println("doit() Constants_A"); 16 break; 17 case Constants.Constants_B: 18 System.out.println("doit() Constants_B"); 19 break; 20 } 21 } 22 23 /** 定义一个方法，这里的参数为枚举类型对象 */ 24 public static void doit2(Constants2 c) { 25 switch (c) { // 根据枚举类型对象做不同操作 26 case Constants_A: 27 System.out.println("doit2() Constants_A"); 28 break; 29 case Constants_B: 30 System.out.println("doit2() Constants_B"); 31 break; 32 } 33 } 34 35 public static void main(String[] args) { 36 ConstantsTest.doit(Constants.Constants_A); // 使用接口中定义的常量 37 ConstantsTest.doit(12); 38 ConstantsTest.doit(Constants.Constants_B); 39 ConstantsTest.doit2(Constants2.Constants_A); // 使用枚举类型中的常量 40 ConstantsTest.doit2(Constants2.Constants_B); // 使用枚举类型中的常量 41 ConstantsTest.doit(2); 42 //ConstantsTest.doit2(2); // 报错 43 } 44 }
运行结果：
doit() Constants_A
doit() Constants_B
doit() Constants_B
doit2() Constants_A
doit2() Constants_B
分析：在上述代码中，当用户调用doit（）方法时，编译器不接受在接口中定义的常量参数，也不会报错，但调用doit2（）方法时，任意传递的参数，编译器就会报错，因为这个方法只接受枚举类型的常量作为其参数。