一、为什么需要枚举

常量定义它不香吗？为啥非得用枚举？
举个栗子，就以B站上传视频为例，视频一般有三个状态：草稿、审核和发布，我们可以将其定义为静态常量：

  1. public class VideoStatus {
  3.     public static final int Draft = 1; //草稿
  5.     public static final int Review = 2; //审核
  7.     public static final int Published = 3; //发布
  8. }

对于这种单值类型的静态常量定义，本身也没错，主要是在使用的地方没有一个明确性的约束而已，比如：

  1. void judgeVideoStatus( int status ) {
  3.     ...
  5. }

比如这里的 judgeVideoStatus 函数的本意是传入 VideoStatus 的三种静态常量之一，但由于没有类型上的约束，因此传入任意一个int值都是可以的，编译器也不会提出任何警告。

但是在枚举类型出现之后，上面这种情况就可以用枚举严谨地去约束，比如用枚举去定义视频状态就非常简洁了：

  1. public enum VideoStatus {
  2.     Draft, Review, Published
  3. }

而且主要是在用枚举的地方会有更强的类型约束：

  1. // 入参就有明确类型约束
  2. void judgeVideoStatus( VideoStatus status ) {
  4.     ...
  6. }

这样在使用 judgeVideoStatus 函数时，入参类型就会受到明确的类型约束，一旦传入无效值，编译器就会帮我们检查，从而规避潜在问题。
除此之外，枚举在扩展性方面比普常量更方便、也更优雅。

二、重新系统认识一下枚举

比如，在后台管理系统中，肯定有用户角色一说，而且角色一般都是固定的，适合定义成一个枚举：

  1. public enum UserRole {
  3.     ROLE_ROOT_ADMIN,  // 系统管理员
  5.     ROLE_ORDER_ADMIN, // 订单管理员
  7.     ROLE_NORMAL       // 普通用户
  8. }

接下来我们就用这个UserRole为例来说明枚举的所有基本用法：

  1. UserRole role1 = UserRole.ROLE_ROOT_ADMIN;
  2. UserRole role2 = UserRole.ROLE_ORDER_ADMIN;
  3. UserRole role3 = UserRole.ROLE_NORMAL;
  5. // values()方法：返回所有枚举常量的数组集合
  6. for ( UserRole role : UserRole.values() ) {
  7.     System.out.println(role);
  8. }
  9. // 打印：
  10. // ROLE_ROOT_ADMIN
  11. // ROLE_ORDER_ADMIN
  12. // ROLE_NORMAL
  14. // ordinal()方法：返回枚举常量的序数，注意从0开始
  15. System.out.println( role1.ordinal() ); // 打印0
  16. System.out.println( role2.ordinal() ); // 打印1
  17. System.out.println( role3.ordinal() ); // 打印2
  19. // compareTo()方法：枚举常量间的比较
  20. System.out.println( role1.compareTo(role2) ); //打印-1
  21. System.out.println( role2.compareTo(role3) ); //打印-2
  22. System.out.println( role1.compareTo(role3) ); //打印-2
  24. // name()方法：获得枚举常量的名称
  25. System.out.println( role1.name() ); // 打印ROLE_ROOT_ADMIN
  26. System.out.println( role2.name() ); // 打印ROLE_ORDER_ADMIN
  27. System.out.println( role3.name() ); // 打印ROLE_NORMAL
  29. // valueOf()方法：返回指定名称的枚举常量
  30. System.out.println( UserRole.valueOf( "ROLE_ROOT_ADMIN" ) );
  31. System.out.println( UserRole.valueOf( "ROLE_ORDER_ADMIN" ) );
  32. System.out.println( UserRole.valueOf( "ROLE_NORMAL" ) );

除此之外，枚举还可以用于switch语句中，而且意义更加明确

  1. UserRole userRole = UserRole.ROLE_ORDER_ADMIN;
  2. switch (userRole) {
  3.     case ROLE_ROOT_ADMIN:  // 比如此处的意义就非常清晰了，比1，2，3这种数字好！
  4.         System.out.println("这是系统管理员角色");
  5.         break;
  6.     case ROLE_ORDER_ADMIN:
  7.         System.out.println("这是订单管理员角色");
  8.         break;
  9.     case ROLE_NORMAL:
  10.         System.out.println("这是普通用户角色");
  11.         break;
  12. }

自定义扩充枚举

上面展示的枚举例子非常简单，仅仅是单值的情形，而实际项目中用枚举往往是多值用法。

比如，我想扩充一下上面的UserRole枚举，在里面加入 角色名 — 角色编码 的对应关系，这也是实际项目中常用的用法。

这时候我们可以在枚举里自定义各种属性、构造函数、甚至各种方法：

  1. public enum UserRole {
  3.     ROLE_ROOT_ADMIN( "系统管理员", 000000 ),
  4.     ROLE_ORDER_ADMIN( "订单管理员", 100000 ),
  5.     ROLE_NORMAL( "普通用户", 200000 ),
  6.     ;
  8.     // 以下为自定义属性
  10.     private final String roleName;  //角色名称
  12.     private final Integer roleCode; //角色编码
  14.     // 以下为自定义构造函数
  16.     UserRole( String roleName, Integer roleCode ) {
  17.         this.roleName = roleName;
  18.         this.roleCode = roleCode;
  19.     }
  21.     // 以下为自定义方法
  23.     public String getRoleName() {
  24.         return this.roleName;
  25.     }
  27.     public Integer getRoleCode() {
  28.         return this.roleCode;
  29.     }
  31.     public static Integer getRoleCodeByRoleName( String roleName ) {
  32.         for( UserRole enums : UserRole.values() ) {
  33.             if( enums.getRoleName().equals( roleName ) ) {
  34.                 return enums.getRoleCode();
  35.             }
  36.         }
  37.         return null;
  38.     }
  40. }

从上述代码可知，在enum枚举类中完全可以像在普通Class里一样声明属性、构造函数以及成员方法。

枚举 + 接口 = ?

比如在我的前文《答应我，别再if/else走天下了可以吗》中讲烦人的if/else消除时，就讲过如何通过让枚举去实现接口来方便的完成。
这地方不妨再回顾一遍：
什么角色能干什么事，这很明显有一个对应关系，所以我们首先定义一个公用的接口RoleOperation，表示不同角色所能做的操作：

  1. public interface RoleOperation {
  2.     String op();  // 表示某个角色可以做哪些op操作
  3. }

接下来我们将不同角色的情况全部交由枚举类来做，定义一个枚举类RoleEnum，并让它去实现RoleOperation接口：

  1. public enum RoleEnum implements RoleOperation {
  3.     // 系统管理员(有A操作权限)
  4.     ROLE_ROOT_ADMIN {
  5.         @Override
  6.         public String op() {
  7.             return "ROLE_ROOT_ADMIN:" + " has AAA permission";
  8.         }
  9.     },
  11.     // 订单管理员(有B操作权限)
  12.     ROLE_ORDER_ADMIN {
  13.         @Override
  14.         public String op() {
  15.             return "ROLE_ORDER_ADMIN:" + " has BBB permission";
  16.         }
  17.     },
  19.     // 普通用户(有C操作权限)
  20.     ROLE_NORMAL {
  21.         @Override
  22.         public String op() {
  23.             return "ROLE_NORMAL:" + " has CCC permission";
  24.         }
  25.     };
  26. }

这样，在调用处就变得异常简单了，一行代码就行了，根本不需要什么if/else：

  1. public class JudgeRole {
  2.     public String judge( String roleName ) {
  3.         // 一行代码搞定！之前的if/else灰飞烟灭
  4.         return RoleEnum.valueOf(roleName).op();
  5.     }
  6. }

而且这样一来，以后假如我想扩充条件，只需要去枚举类中加代码即可，而不用改任何老代码，非常符合开闭原则！

枚举与设计模式

什么？枚举还能实现设计模式？
是的！不仅能而且还能实现好几种！

2、策略模式
这个也比较好举例，比如用枚举就可以写出一个基于策略模式的加减乘除计算器

  1. public class Test {
  3.     public enum Calculator {
  5.         ADDITION {
  6.             public Double execute( Double x, Double y ) {
  7.                 return x + y; // 加法
  8.             }
  9.         },
  11.         SUBTRACTION {
  12.             public Double execute( Double x, Double y ) {
  13.                 return x - y; // 减法
  14.             }
  15.         },
  17.         MULTIPLICATION {
  18.             public Double execute( Double x, Double y ) {
  19.                 return x * y; // 乘法
  20.             }
  21.         },
  24.         DIVISION {
  25.             public Double execute( Double x, Double y ) {
  26.                 return x/y;  // 除法
  27.             }
  28.         };
  30.         public abstract Double execute(Double x, Double y);
  31.     }
  33.     public static void main(String[] args) {
  34.         System.out.println( Calculator.ADDITION.execute( 4.0, 2.0 ) );       
  35.         // 打印 6.0
  36.         System.out.println( Calculator.SUBTRACTION.execute( 4.0, 2.0 ) );    
  37.         // 打印 2.0
  38.         System.out.println( Calculator.MULTIPLICATION.execute( 4.0, 2.0 ) ); 
  39.         // 打印 8.0
  40.         System.out.println( Calculator.DIVISION.execute( 4.0, 2.0 ) );       
  41.         // 打印 2.0
  42.     }
  43. }

专门用于枚举的集合类

我们平常一般习惯于使用诸如：HashMap 和 HashSet等集合来盛放元素，而对于枚举，有它专门的集合类：EnumSet和EnumMap
1、EnumSet
EnumSet 是专门为盛放枚举类型所设计的 Set 类型。
还是举例来说，就以文中开头定义的角色枚举为例：

  1. public enum UserRole {
  3.     ROLE_ROOT_ADMIN,  // 系统管理员
  5.     ROLE_ORDER_ADMIN, // 订单管理员
  7.     ROLE_NORMAL       // 普通用户
  8. }

比如系统里来了一批人，我们需要查看他是不是某个角色中的一个：

  1. // 定义一个管理员角色的专属集合
  2. EnumSet<UserRole> userRolesForAdmin 
  3.     = EnumSet.of( 
  4.         UserRole.ROLE_ROOT_ADMIN,
  5.         UserRole.ROLE_ORDER_ADMIN 
  6.     );
  8. // 判断某个进来的用户是不是管理员
  9. Boolean isAdmin( User user ) {
  11.     if( userRoles.contains( user.getUserRole() ) )
  12.         return true;
  14.     return false;
  15. }

2、EnumMap
同样，EnumMap 则是用来专门盛放枚举类型为key的 Map 类型。
比如，系统里来了一批人，我们需要统计不同的角色到底有多少人这种的话：

  1. Map<UserRole,Integer> userStatisticMap = new EnumMap<>(UserRole.class);
  3. for ( User user : userList ) {
  4.     Integer num = userStatisticMap.get( user.getUserRole() );
  5.     if( null != num ) {
  6.         userStatisticMap.put( user.getUserRole(), num+1 );
  7.     } else {
  8.         userStatisticMap.put( user.getUserRole(), 1 );
  9.     }
  10. }