1 简述你对枚举的理解

枚举是 JDK5 版本新增的特性(泛型、For-each等如今被广泛应用的特性也是由 JDK5 时所新增的)，另外到了 JDK6 后 switch 语句支持枚举类型。
枚举具有以下特征：

  • 使用关键字 enum
  • 枚举可以单独定义在一个文件中，也可以嵌在其它Java类中
  • 枚举可以实现一个或多个接口（Interface）
  • 枚举可以定义新的变量
  • 枚举可以定义新的方法
  • 枚举可以定义根据具体枚举值而相异的类
  • 枚举不能被继承

    2 枚举与常量类的区别

    使用枚举的方式定义常量让代码更具有可读性，运行进行编译时检查，预先设定可接收值的范围，避免因为传入非法值导致的意外问题。
常量类 枚举
编译时 常量类编译时，是直接把常量的值编译到类的二进制代码里，常量的值在升级中变化后，需要重新编译引用常量的类，因为里面存的是旧值。 枚举类编译时，没有把常量值编译到代码里，即使常量的值发生变化，也不会影响引用常量的类。
编译后 常量类可被继承修改、增加字段等，容易导致父类的不兼容。 枚举类编译后默认为 final-class ，不允许继承，防止被子类修改。
比较 当使用常量类时，往往通过 equals 去判断两者是否相等。 枚举类确保JVM只存在一个常量实例，即常量值地址唯一，可以用==直接对比，性能会有提高。
switch 语句 当 switch 使用 int 、 String 类型时，由于值的不稳定性往往会有越界的现象，对于这个的处理往往只能通过 if 条件筛选以及 default 模块来处理。 使用枚举型后，在编译期间限定类型，不允许发生越界的情况。

3 枚举的本质

枚举类在编译后会生成一个新的final class，这个类继承于 java.lang.Enum 。当一个 Java 类第一次被使用时，静态资源会被初始化，而 Java 类的加载以及初始化过程都是线程安全的，所以创建一个枚举类是线程安全的。
枚举类在用于单例模式时可以有效地执行单例。请见Java 利用枚举实现单例模式

4 枚举与序列化的关系

在使用单例模式时，绝大多数单例的实现方式一旦实现了 Serializable 接口后，由于反射的存在，单例特性被破坏，每次调用 readObject 方法返回的都是一个新创建的对象。
Java 对枚举做了特殊规定，使得每一个枚举类定义的枚举变量在 JVM 中都是唯一的。在序列化的时候 Java 仅仅是将枚举对象的 name 属性输出到结果中，反序列化的时候则是通过 java.lang.Enum 的valueOf 方法来根据名字查找枚举对象。同时，编译器是不允许任何对这种序列化机制的定制的，因此禁用了 writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。

5 在switch语句中使用枚举类型

直接看一个例子。

  1. package org.example;
  3. public class EnumTest3 {
  4.     // 创建一个枚举类
  5.     enum State {
  6.         MONDAY,
  7.         TUESDAY,
  8.         WEDNESDAY,
  9.         THURSDAY,
  10.         FRIDAY,
  11.         SATURDAY,
  12.         SUNDAY;
  13.     }
  14.     private State state;
  16.     public State getState() {
  17.         return state;
  18.     }
  20.     public void setState(State state) {
  21.         this.state = state;
  22.     }
  24.     // 根据枚举类的属性取对应的值
  25.     public int getTime() {
  26.         switch (state) {
  27.             case MONDAY:
  28.                 return 1;
  29.             case TUESDAY:
  30.                 return 2;
  31.             case WEDNESDAY:
  32.                 return 3;
  33.             case THURSDAY:
  34.                 return 4;
  35.             case FRIDAY:
  36.                 return 5;
  37.             case SATURDAY:
  38.                 return 6;
  39.             case SUNDAY:
  40.                 return 7;
  41.         }
  42.         return 0;
  43.     }
  44.     public static void main(String[] args) {
  45.         EnumTest3 e = new EnumTest3();
  46.         e.setState(State.FRIDAY);
  47.         int time = e.getTime();
  48.         System.out.println(time);
  49.     }
  50. }

6 枚举类代替if/switch

  • 定义一个任务接口。
  • 定义枚举类，并实现任务接口。
    • 设置属性的同时，实现任务接口中指定的任务。
    • 定义一个getInstance方法，指定获取枚举类属性的方法
  • 使用枚举类对象。

具体步骤如下代码所示：

  1. package org.example;
  3. // 利用Enum类替换if/switch
  4. public class EnumTest4 {
  5.     // 新建一个接口，定义需要执行的任务
  6.     public interface getTime {
  7.         int getTodayTime();
  8.         void sayHello();
  9.     }
  11.     // 定义枚举类的同时，实现每个属性对应的任务
  12.     enum State implements getTime {
  13.         MONDAY (1) {
  14.             @Override
  15.             public int getTodayTime() {
  16.                 return 111;
  17.             }
  19.             @Override
  20.             public void sayHello() {
  21.                 System.out.println("今天是星期一");
  22.             }
  23.         },
  24.         TUESDAY (2) {
  25.             @Override
  26.             public int getTodayTime() {
  27.                 return 222;
  28.             }
  29.             @Override
  30.             public void sayHello() {
  31.                 System.out.println("今天是星期二");
  32.             }
  33.         },
  34.         WEDNESDAY (3) {
  35.             @Override
  36.             public int getTodayTime() {
  37.                 return 333;
  38.             }
  39.             @Override
  40.             public void sayHello() {
  41.                 System.out.println("今天是星期三");
  42.             }
  43.         },
  44.         THURSDAY (4) {
  45.             @Override
  46.             public int getTodayTime() {
  47.                 return 444;
  48.             }
  49.             @Override
  50.             public void sayHello() {
  51.                 System.out.println("今天是星期四");
  52.             }
  53.         },
  54.         FRIDAY (5) {
  55.             @Override
  56.             public int getTodayTime() {
  57.                 return 555;
  58.             }
  59.             @Override
  60.             public void sayHello() {
  61.                 System.out.println("今天是星期五");
  62.             }
  63.         },
  64.         SATURDAY (6) {
  65.             @Override
  66.             public int getTodayTime() {
  67.                 return 666;
  68.             }
  69.             @Override
  70.             public void sayHello() {
  71.                 System.out.println("今天是星期六");
  72.             }
  73.         },
  74.         SUNDAY (7) {
  75.             @Override
  76.             public int getTodayTime() {
  77.                 return 777;
  78.             }
  79.             @Override
  80.             public void sayHello() {
  81.                 System.out.println("今天是星期天");
  82.             }
  83.         };
  85.         // 定义Enum的参数，用于判断具体调用哪个属性
  86.         int time;
  88.         State(int i) {
  89.             this.time = i;
  90.         }
  92.         // 返回指定的Enum属性对象
  93.         public static State getInstance(int time) {
  94.             // 遍历Enum定义的属性
  95.             for (State state : State.values()) {
  96.                 // 如果有相等的，则返回对应的属性
  97.                 if (state.time == time) {
  98.                     return state;
  99.                 }
  100.             }
  101.             return null;
  102.         }
  103.     }
  105.     public static void main(String[] args) {
  106.         // 使用枚举类代替if/switch
  107.         int time = 2;
  108.         // 获取指定的Enum对象
  109.         State state = State.getInstance(time);
  110.         // 调用方法
  111.         int todayTime = state.getTodayTime();
  112.         state.sayHello();
  113.         System.out.println(todayTime);
  115.         // 正常调用枚举类的属性
  116.         System.out.println(State.FRIDAY);
  117.     }
  118. }

参考