Java基础14-深入理解Java枚举类(一）

enum <枚举类型名> 
　　{ <枚举元素表> };
　　
　　其中：关键词enum表示定义的是枚举类型，枚举类型名由标识符组成，而枚举元素表由枚举元素或枚举常量组成。例如： 
　　
enum weekdays 
　　{ Sun,Mon,Tue,Wed,Thu,Fri,Sat };
　　定义了一个名为 weekdays的枚举类型，它包含七个元素：Sun、Mon、Tue、Wed、Thu、Fri、Sat。复制代码

例如，描述逻辑值集合{TRUE、FALSE}的枚举类型boolean可定义如下：
enum boolean 
　　{ TRUE=1 ,FALSE=0 };
该定义规定：TRUE的值为1，而FALSE的值为0。
　　
而描述颜色集合{red,blue,green,black,white,yellow}的枚举类型colors可定义如下：
enum colors 
　　{red=5,blue=1,green,black,white,yellow};
　　该定义规定red为5 ，blue为1，其后元素值从2 开始递增加1。green、black、white、yellow的值依次为2、3、4、5。复制代码

public class 常量 {
}
enum Color {
    Red, Green, Blue, Yellow
}复制代码

public static void showColor(Color color) {
        switch (color) {
            case Red:
                System.out.println(color);
                break;
            case Blue:
                System.out.println(color);
                break;
            case Yellow:
                System.out.println(color);
                break;
            case Green:
                System.out.println(color);
                break;
        }
    }复制代码

enum Color {
    //每个颜色都是枚举类的一个实例，并且构造方法要和枚举类的格式相符合。
    //如果实例后面有其他内容，实例序列结束时要加分号。
    Red("红色", 1), Green("绿色", 2), Blue("蓝色", 3), Yellow("黄色", 4);
    String name;
    int index;
    Color(String name, int index) {
        this.name = name;
        this.index = index;
    }
    public void showAllColors() {
        //values是Color实例的数组，在通过index和name可以获取对应的值。
        for (Color color : Color.values()) {
            System.out.println(color.index + ":" + color.name);
        }
    }
}复制代码

@Override
public String toString() {
    return this.index + ":" + this.name;
}复制代码

enum Color implements Print{
    @Override
    public void print() {
        System.out.println(this.name);
    }
}复制代码

public class 用接口组织枚举 {
    public static void main(String[] args) {
        Food cf = chineseFood.dumpling;
        Food jf = Food.JapaneseFood.fishpiece;
        for (Food food : chineseFood.values()) {
            System.out.println(food);
        }
        for (Food food : Food.JapaneseFood.values()) {
            System.out.println(food);
        }
    }
}
interface Food {
    enum JapaneseFood implements Food {
        suse, fishpiece
    }
}
enum chineseFood implements Food {
    dumpling, tofu
}复制代码

public class 枚举类集合 {
    public static void main(String[] args) {
        EnumMap<Color, String> map = new EnumMap<Color, String>(Color.class);
        map.put(Color.Blue, "Blue");
        map.put(Color.Yellow, "Yellow");
        map.put(Color.Red, "Red");
        System.out.println(map.get(Color.Red));
    }
}复制代码

public class 枚举类集合 {
    public static void main(String[] args) {
        EnumMap<Color, String> map = new EnumMap<Color, String>(Color.class);
        map.put(Color.Blue, "Blue");
        map.put(Color.Yellow, "Yellow");
        map.put(Color.Red, "Red");
        System.out.println(map.get(Color.Red));
    }
}复制代码

public enum Day {
    MONDAY {
        @Override
        void say() {
            System.out.println("MONDAY");
        }
    }
    , TUESDAY {
        @Override
        void say() {
            System.out.println("TUESDAY");
        }
    }, FRIDAY("work"){
        @Override
        void say() {
            System.out.println("FRIDAY");
        }
    }, SUNDAY("free"){
        @Override
        void say() {
            System.out.println("SUNDAY");
        }
    };
    String work;
    //没有构造参数时，每个实例可以看做常量。
    //使用构造参数时，每个实例都会变得不一样，可以看做不同的类型，所以编译后会生成实例个数对应的class。
    private Day(String work) {
        this.work = work;
    }
    private Day() {

    }
    //枚举实例必须实现枚举类中的抽象方法
    abstract void say ();

}复制代码

D:\MyTech\out\production\MyTech\com\javase\枚举类>javap Day.class
Compiled from "Day.java"

public abstract class com.javase.枚举类.Day extends java.lang.Enum<com.javase.枚举类.Day> {
  public static final com.javase.枚举类.Day MONDAY;
  public static final com.javase.枚举类.Day TUESDAY;
  public static final com.javase.枚举类.Day FRIDAY;
  public static final com.javase.枚举类.Day SUNDAY;
  java.lang.String work;
  public static com.javase.枚举类.Day[] values();
  public static com.javase.枚举类.Day valueOf(java.lang.String);
  abstract void say();
  com.javase.枚举类.Day(java.lang.String, int, com.javase.枚举类.Day$1);
  com.javase.枚举类.Day(java.lang.String, int, java.lang.String, com.javase.枚举类.Day$1);
  static {};
}复制代码

InnerClasses:
     static #23; //class com/javase/枚举类/Day$4
     static #18; //class com/javase/枚举类/Day$3
     static #14; //class com/javase/枚举类/Day$2
     static #10; //class com/javase/枚举类/Day$1复制代码

static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=5, locals=0, args_size=0
         0: new           #10                 // class com/javase/枚举类/Day$1
         3: dup
         4: ldc           #11                 // String MONDAY
         6: iconst_0
         7: invokespecial #12                 // Method com/javase/枚举类/Day$1."<init>":(Ljava/lang/String;I)V
        10: putstatic     #13                 // Field MONDAY:Lcom/javase/枚举类/Day;
        13: new           #14                 // class com/javase/枚举类/Day$2
        16: dup
        17: ldc           #15                 // String TUESDAY
        19: iconst_1
        20: invokespecial #16                 // Method com/javase/枚举类/Day$2."<init>":(Ljava/lang/String;I)V
        //后面类似，这里省略
}复制代码

public static com.javase.Day[] values();  
  flags: ACC_PUBLIC, ACC_STATIC  
  Code:  
    stack=1, locals=0, args_size=0  
       0: getstatic     #2                  // Field $VALUES:[Lcom/javase/Day;  
       3: invokevirtual #3                  // Method "[Lcom/mikan/Day;".clone:()Ljava/lang/Object;  
       6: checkcast     #4                  // class "[Lcom/javase/Day;"  
       9: areturn  
这个方法是一个公共的静态方法，所以我们可以直接调用该方法（Day.values()）,返回这个枚举值的数组，另外，这个方法的实现是，克隆在静态代码块中初始化的$VALUES字段的值，并把类型强转成Day[]类型返回。复制代码

从Enum类中我们可以看到，为每个枚举都定义了两个属性，name和ordinal，name表示我们定义的枚举常量的名称，如FRIDAY、TUESDAY，而ordinal是一个顺序号，根据定义的顺序分别赋予一个整形值，从0开始。在枚举常量初始化时，会自动为初始化这两个字段，设置相应的值，所以才在构造方法中添加了两个参数。即：

另外三个枚举常量生成的内部类基本上差不多，这里就不重复说明了。复制代码