title: 【JAVA】浅谈java枚举类date: 2019-11-06 23:35:25
tags:
categories:

原文
原文排版看起来难受

一、什么情况下使用枚举类？

有的时候一个类的对象是有限且固定的，这种情况下我们使用枚举类就比较方便？

二、为什么不用静态常量来替代枚举类呢？

  1. public static final int SEASON_SPRING = 1;
  2. public static final int SEASON_SUMMER = 2;
  3. public static final int SEASON_FALL = 3;
  4. public static final int SEASON_WINTER = 4;

枚举类更加直观，类型安全。使用常量会有以下几个缺陷：

  1. 类型不安全。若一个方法中要求传入季节这个参数，用常量的话，形参就是int类型，开发者传入任意类型的int类型值就行，但是如果是枚举类型的话，就只能传入枚举类中包含的对象。

  2. 没有命名空间。开发者要在命名的时候以SEASON_开头，这样另外一个开发者再看这段代码的时候，才知道这四个常量分别代表季节。

三、枚举类入门

先看一个简单的枚举类。

  1. package enumcase;
  3. public enum SeasonEnum {
  4.     SPRING, SUMMER, FALL, WINTER;
  5. }

enum和class、interface的地位一样
使用enum定义的枚举类默认继承了java.lang.Enum，而不是继承Object类。枚举类可以实现一个或多个接口。
枚举类的所有实例都必须放在第一行展示，不需使用new 关键字，不需显式调用构造器。自动添加public static final修饰。
使用enum定义、非抽象的枚举类默认使用final修饰，不可以被继承。
枚举类的构造器只能是私有的。

四、枚举类介绍

枚举类内也可以定义属性和方法，可是是静态的和非静态的。

  1. package enumcase;
  3. public enum SeasonEnum {
  4.     SPRING("春天"), SUMMER("夏天"), FALL("秋天"), WINTER("冬天");
  6.     private final String name;
  8.     private SeasonEnum(String name) {
  9.         this.name = name;
  10.     }
  12.     public String getName() {
  13.         return name;
  14.     }
  15. }

实际上在第一行写枚举类实例的时候，默认是调用了构造器的，所以此处需要传入参数，因为没有显式申明无参构造器，只能调用有参数的构造器。

构造器需定义成私有的，这样就不能在别处申明此类的对象了。枚举类通常应该设计成不可变类，它的Field不应该被改变，这样会更安全，而且代码更加简洁。所以我们将Field用private final修饰。

五、枚举类实现接口

枚举类可以实现一个或多个接口。与普通类一样，实现接口的时候需要实现接口中定义的所有方法，若没有完全实现，那这个枚举类就是抽象的，只是不需显式加上abstract修饰，系统化会默认加上。

  1. package enumcase;
  3. public enum Operation {
  4.     PLUS {
  5.         @Override
  6.         public double eval(double x, double y) {
  7.             return x + y;
  8.         }
  9.     },
  10.     MINUS {
  11.         @Override
  12.         public double eval(double x, double y) {
  13.             return x - y;
  14.         }
  15.     },
  16.     TIMES {
  17.         @Override
  18.         public double eval(double x, double y) {
  19.             return x * y;
  20.         }
  21.     },
  22.     DIVIDE {
  23.         @Override
  24.         public double eval(double x, double y) {
  25.             return x / y;
  26.         }
  27.     };
  29.     /**
  30.      * 抽象方法，由不同的枚举值提供不同的实现。
  31.      *
  32.      * @param x
  33.      * @param y
  34.      * @return
  35.      */
  36.     public abstract double eval(double x, double y);
  38.     public static void main(String[] args) {
  39.         System.out.println(Operation.PLUS.eval(10, 2));
  40.         System.out.println(Operation.MINUS.eval(10, 2));
  41.         System.out.println(Operation.TIMES.eval(10, 2));
  42.         System.out.println(Operation.DIVIDE.eval(10, 2));
  43.     }
  44. }

Operatio类实际上是抽象的，不可以创建枚举值，所以此处在申明枚举值的时候，都实现了抽象方法，这其实是匿名内部类的实现，花括号部分是一个类体。我们可以看下编译以后的文件。

共生成了五个class文件，这样就证明了PLUS,MINUS,TIMES,DIVIDE是Operation的匿名内部类的实例。

六、switch语句里的表达式可以是枚举值

Java5新增了enum关键字，同时扩展了switch。

  1. package enumcase;
  3. public class SeasonTest {
  4.     public void judge(SeasonEnum s) {
  5.         switch (s) {
  6.             case SPRING:
  7.                 System.out.println("春天适合踏青。");
  8.                 break;
  9.             case SUMMER:
  10.                 System.out.println("夏天要去游泳啦。");
  11.                 break;
  12.             case FALL:
  13.                 System.out.println("秋天一定要去旅游哦。");
  14.                 break;
  15.             case WINTER:
  16.                 System.out.println("冬天要是下雪就好啦。");
  17.                 break;
  18.         }
  19.     }
  20.     public static void main(String[] args) {
  21.         SeasonEnum s = SeasonEnum.SPRING;
  22.         SeasonTest test = new SeasonTest();
  23.         test.judge(s);
  24.     }
  25. }

case表达式中直接写入枚举值，不需加入枚举类作为限定。