枚举

语法（定义）
创建枚举类型要使用 enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类（java.lang.Enum 是一个抽象类）。枚举类型符合通用模式 Class Enum<E extends Enum>，而 E 表示枚举类型的名称。枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal) 构造函数中，在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了此设置被创建的顺序。
package com.hmw.test;
/**

• 枚举测试类

• @author 汝妮娑鸢
  */
  public enum EnumTest {
  MON, TUE, WED, THU, FRI, SAT, SUN;
  }
  这段代码实际上调用了7次 Enum(String name, int ordinal)：
  new Enum("MON",0);
  new Enum("TUE",1);
  new Enum("WED",2);
  ... ...
  遍历、switch 等常用操作
  对enum进行遍历和switch的操作示例代码：
  public class Test {
  public static void main(String[] args) {
  for (EnumTest e : EnumTest.values()) {
  System.out.println(e.toString());
  }

   System.out.println("----------------我是分隔线------------------");
    
   EnumTest test = EnumTest.TUE;
   switch (test) {
   case MON:
       System.out.println("今天是星期一");
       break;
   case TUE:
       System.out.println("今天是星期二");
       break;
   // ... ...
   default:
       System.out.println(test);
       break;
   }
  

  }
  }
  输出结果：
  MON
  TUE
  WED
  THU
  FRI
  SAT
  SUN
  ----------------我是分隔线------------------
  今天是星期二
  enum 对象的常用方法介绍
  int compareTo(E o)
  比较此枚举与指定对象的顺序。
  Class getDeclaringClass()
  返回与此枚举常量的枚举类型相对应的 Class 对象。
  String name()
  返回此枚举常量的名称，在其枚举声明中对其进行声明。
  int ordinal()
  返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
  String toString()
  返回枚举常量的名称，它包含在声明中。
  static <T extends Enum> T valueOf(Class enumType, String name)
  返回带指定名称的指定枚举类型的枚举常量。
  public class Test {
  public static void main(String[] args) {
  EnumTest test = EnumTest.TUE;

   //compareTo(E o)
   switch (test.compareTo(EnumTest.MON)) {
   case -1:
       System.out.println("TUE 在 MON 之前");
       break;
   case 1:
       System.out.println("TUE 在 MON 之后");
       break;
   default:
       System.out.println("TUE 与 MON 在同一位置");
       break;
   }
    
   //getDeclaringClass()
   System.out.println("getDeclaringClass(): " + test.getDeclaringClass().getName());
    
   //name() 和  toString()
   System.out.println("name(): " + test.name());
   System.out.println("toString(): " + test.toString());
    
   //ordinal()， 返回值是从 0 开始
   System.out.println("ordinal(): " + test.ordinal());
  

  }
  }
  输出结果：
  TUE 在 MON 之后
  getDeclaringClass(): com.hmw.test.EnumTest
  name(): TUE
  toString(): TUE
  ordinal(): 1
  给 enum 自定义属性和方法
  给 enum 对象加一下 value 的属性和 getValue() 的方法：
  package com.hmw.test;

/**

• 枚举测试类

• @author 汝妮娑鸢
  */
  public enum EnumTest {
  MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6) {
  @Override
  public boolean isRest() {
  return true;
  }
  },
  SUN(0) {
  @Override
  public boolean isRest() {
  return true;
  }
  };

  private int value;

  private EnumTest(int value) {
  this.value = value;
  }

  public int getValue() {
  return value;
  }

  public boolean isRest() {
  return false;
  }
  }
  public class Test {
  public static void main(String[] args) {
  System.out.println("EnumTest.FRI 的 value = " + EnumTest.FRI.getValue());
  }
  }
  输出结果：
  EnumTest.FRI 的 value = 5
  EnumSet，EnumMap 的应用
  public class Test {
  public static void main(String[] args) {
  // EnumSet的使用
  EnumSet weekSet = EnumSet.allOf(EnumTest.class);
  for (EnumTest day : weekSet) {
  System.out.println(day);
  }

   // EnumMap的使用
   EnumMap<EnumTest, String> weekMap = new EnumMap(EnumTest.class);
   weekMap.put(EnumTest.MON, "星期一");
   weekMap.put(EnumTest.TUE, "星期二");
   // ... ...
   for (Iterator<Entry<EnumTest, String>> iter = weekMap.entrySet().iterator(); iter.hasNext();) {
       Entry<EnumTest, String> entry = iter.next();
       System.out.println(entry.getKey().name() + ":" + entry.getValue());
   }
  

  }
  }
  原理分析
  enum 的语法结构尽管和 class 的语法不一样，但是经过编译器编译之后产生的是一个class文件。该class文件经过反编译可以看到实际上是生成了一个类，该类继承了java.lang.Enum。EnumTest 经过反编译(javap com.hmw.test.EnumTest 命令)之后得到的内容如下：
  public class com.hmw.test.EnumTest extends java.lang.Enum{
  public static final com.hmw.test.EnumTest MON;
  public static final com.hmw.test.EnumTest TUE;
  public static final com.hmw.test.EnumTest WED;
  public static final com.hmw.test.EnumTest THU;
  public static final com.hmw.test.EnumTest FRI;
  public static final com.hmw.test.EnumTest SAT;
  public static final com.hmw.test.EnumTest SUN;
  static {};
  public int getValue();
  public boolean isRest();
  public static com.hmw.test.EnumTest[] values();
  public static com.hmw.test.EnumTest valueOf(java.lang.String);
  com.hmw.test.EnumTest(java.lang.String, int, int, com.hmw.test.EnumTest);
  }
  所以，实际上 enum 就是一个 class，只不过 java 编译器帮我们做了语法的解析和编译而已。
  总结
  可以把 enum 看成是一个普通的 class，它们都可以定义一些属性和方法，不同之处是：enum 不能使用 extends 关键字继承其他类，因为 enum 已经继承了 java.lang.Enum（java是单一继承）。

---------------------------------------------------Ⅱ---------------------------------------------------------------

一：Enum 类型的介绍
　　枚举类型（Enumerated Type） 很早就出现在编程语言中，它被用来将一组类似的值包含到一种类型当中。而这种枚举类型的名称则会被定义成独一无二的类型描述符，在这一点上和常量的定义相似。不过相比较常量类型，枚举类型可以为申明的变量提供更大的取值范围。
二：Enum 类型的特点
在某些情况下，一个类的对象时有限且固定的，如季节类，它只有春夏秋冬4个对象这种实例有限且固定的类，在 Java 中被称为枚举类；
在 Java 中使用 enum 关键字来定义枚举类，其地位与 class、interface 相同；
枚举类是一种特殊的类，它和普通的类一样，有自己的成员变量、成员方法、构造器 (只能使用 private 访问修饰符，所以无法从外部调用构造器，构造器只在构造枚举值时被调用)；
一个 Java 源文件中最多只能有一个 public 类型的枚举类，且该 Java 源文件的名字也必须和该枚举类的类名相同，这点和类是相同的；
使用 enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Seriablizable 和 java.lang.Comparable 两个接口;
所有的枚举值都是 public static final 的，且非抽象的枚举类不能再派生子类；
枚举类的所有实例(枚举值)必须在枚举类的第一行显式地列出，否则这个枚举类将永远不能产生实例。列出这些实例(枚举值)时，系统会自动添加 public static final 修饰，无需程序员显式添加。
三：Enum 使用

package com.ljq.test;

/**

• 枚举用法详解

• @author 汝妮娑鸢
  /
  public class TestEnum {
  /*

  • 普通枚举
  • @author 汝妮娑鸢

  */
  public enum ColorEnum {
  red, green, yellow, blue;
  }

  /**

  • 枚举像普通的类一样可以添加属性和方法，可以为它添加静态和非静态的属性或方法
  • @author 汝妮娑鸢

  */
  public enum SeasonEnum {
  //注：枚举写在最前面，否则编译出错
  spring, summer, autumn, winter;

   private final static String position = "test";
  
   public static SeasonEnum getSeason() {
       if ("test".equals(position))
           return spring;
       else
           return winter;
   }
  

  }

  /**

  • 性别
  • 实现带有构造器的枚举
  • @author 汝妮娑鸢

  */
  public enum Gender{
  //通过括号赋值,而且必须带有一个参构造器和一个属性跟方法，否则编译出错
  //赋值必须都赋值或都不赋值，不能一部分赋值一部分不赋值；如果不赋值则不能写构造器，赋值编译也出错
  MAN("MAN"), WOMEN("WOMEN");

   private final String value;
  
   //构造器默认也只能是private, 从而保证构造函数只能在内部使用
   Gender(String value) {
       this.value = value;
   }
   
   public String getValue() {
       return value;
   }
  

  }

  /**

  • 订单状态
  • 实现带有抽象方法的枚举
  • @author 汝妮娑鸢

  /
  public enum OrderState {
  /* 已取消 /
  CANCEL {public String getName(){return "已取消";}},
  /* 待审核 /
  WAITCONFIRM {public String getName(){return "待审核";}},
  /* 等待付款 /
  WAITPAYMENT {public String getName(){return "等待付款";}},
  /* 正在配货 /
  ADMEASUREPRODUCT {public String getName(){return "正在配货";}},
  /* 等待发货 /
  WAITDELIVER {public String getName(){return "等待发货";}},
  /* 已发货 /
  DELIVERED {public String getName(){return "已发货";}},
  /* 已收货 */
  RECEIVED {public String getName(){return "已收货";}};

   public abstract String getName();
  

  }

  public static void main(String[] args) {
  //枚举是一种类型，用于定义变量，以限制变量的赋值；赋值时通过“枚举名.值”取得枚举中的值
  ColorEnum colorEnum = ColorEnum.blue;
  switch (colorEnum) {
  case red:
  System.out.println("color is red");
  break;
  case green:
  System.out.println("color is green");
  break;
  case yellow:
  System.out.println("color is yellow");
  break;
  case blue:
  System.out.println("color is blue");
  break;
  }

   //遍历枚举
   System.out.println("遍历ColorEnum枚举中的值");
   for(ColorEnum color : ColorEnum.values()){
       System.out.println(color);
   }
   
   //获取枚举的个数
   System.out.println("ColorEnum枚举中的值有"+ColorEnum.values().length+"个");
   
   //获取枚举的索引位置，默认从0开始
   System.out.println(ColorEnum.red.ordinal());//0
   System.out.println(ColorEnum.green.ordinal());//1
   System.out.println(ColorEnum.yellow.ordinal());//2
   System.out.println(ColorEnum.blue.ordinal());//3
   
   //枚举默认实现了java.lang.Comparable接口
   System.out.println(ColorEnum.red.compareTo(ColorEnum.green));//-1
   
   //--------------------------
   System.out.println("===========");
   System.err.println("季节为" + SeasonEnum.getSeason());
   
   
   //--------------
   System.out.println("===========");
   for(Gender gender : Gender.values()){
       System.out.println(gender.value);
   }
  
   //--------------
   System.out.println("===========");
   for(OrderState order : OrderState.values()){
       System.out.println(order.getName());
   }
  

  }

}

四：枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型
JDK5.0 中在增加 Enum 类的同时，也增加了两个工具类 EnumSet 和 EnumMap，这两个类都放在 java.util 包中。EnumSet 是一个针对枚举类型的高性能的 Set 接口实现。EnumSet 中装入的所有枚举对象都必须是同一种类型，在其内部，是通过 bit-vector 来实现，也就是通过一个 long 型数。EnumSet 支持在枚举类型的所有值的某个范围中进行迭代。

enum WeekDayEnum { Mon, Tue, Wed, Thu, Fri, Sat, Sun }
你能够在每周七天日期中进行迭代，EnumSet 类提供一个静态方法 range 让迭代很容易完成：

for(WeekDayEnum day : EnumSet.range(WeekDayEnum.Mon, WeekDayEnum.Fri)) {
System.out.println(day);
}
打印结果如下：

Mon
Tue
Wed
Thu
Fri
EnumSet 还提供了很多个类型安全的获取子集的 of 方法，很容易取得子集：

EnumSet subset = EnumSet.of(WeekDayEnum.Mon, WeekDayEnum.Wed);
for (WeekDayEnum day : subset) {
System.out.println(day);
}
打印结果如下：

Mon
Wed

与 EnumSet 类似，EnumMap 也是一个高性能的 Map 接口实现，用来管理使用枚举类型作为 keys 的映射表，内部是通过数组方式来实现。EnumMap 将丰富的和安全的 Map 接口与数组快速访问结合到一起，如果你希望要将一个枚举类型映射到一个值，你应该使用 EnumMap。看下面的例子：

// 定义一个 EnumMap 对象，映射表主键是日期枚举类型，值是颜色枚举类型
private static Map<WeekDayEnum, RainbowColor> schema =
new EnumMap<WeekDayEnum, RainbowColor>(WeekDayEnum.class);

static{
// 将一周的每一天与彩虹的某一种色彩映射起来
for (int i = 0; i < WeekDayEnum.values().length; i++) {
schema.put(WeekDayEnum.values()[i], RainbowColor.values()[i]);
}
}
System.out.println("What is the lucky color today?");
System.out.println("It's " + schema.get(WeekDayEnum.Sat));

---

1、枚举类在经过编译后确实是生成了一个扩展了java.lang.Enum的类
2、枚举类是final的，因此我们无法再继承它了
3、我们定义的每个枚举值都是该类中的一个成员，且成员的类型仍然是Season类型
4、枚举类中被默认增加了许多静态方法，例如values()、valuesOf()等