【Enum】枚举在 Java 中的常用用法

柔情只为你懂 2023-10-03 12:08 68阅读 0赞

枚举系列文章目录：
【Enum】详解 Java 中的枚举类（上）
【Enum】详解 Java 中的枚举类（下）
【Enum】枚举在 Java 中的常用用法

相信大家通过前面几篇关于“枚举”的博文的学习，大大地提升了对枚举的认识。仅仅地知道枚举的原理不行啊，还得知道怎么去使用它。那么，下面就简单地介绍下枚举的常用用法吧~~

用法一：常量（JDK 1.5）

场景：

页面显示订单列表，且每个订单都有它自己的状态。其订单状态包括：1：未付款；2：已完成；3：待评价。现在需要根据订单状态的数值显示对应的状态（中文）。因为数据库里面存储的值是数值型的。所以，在页面需要转换为对应的中文。

之前，我们一般这样做：在常量类/接口里面定义对应的常量：

  1. public class OrderConstant {
  3.     // 未付款
  4.     public static final Integer NO_PAID = 1;
  5.     // 已完成
  6.     public static final Integer HAS_FINISHED = 2;
  7.     // 待评价
  8.     public static final Integer TO_EVALUATE = 3;
  10.     public static final String MSG_NO_PAID = "未付款";
  11.     public static final String MSG_HAS_FINISHED = "已完成";
  12.     public static final String MSG_TO_EVALUATE = "待评价";
  13. }

然后，在业务逻辑层里面查询订单列表：

  1. public class OrderService {
  4.     private List<TabOrder> orderList = new ArrayList<>();
  6.     public void init() {
  8.         orderList.add(new TabOrder("10001", "u1", OrderConstant.NO_PAID));
  9.         orderList.add(new TabOrder("10002", "u1", OrderConstant.HAS_FINISHED));
  10.         orderList.add(new TabOrder("10003", "u2", OrderConstant.NO_PAID));
  11.         orderList.add(new TabOrder("10004", "u3", OrderConstant.TO_EVALUATE));
  12.         orderList.add(new TabOrder("10005", "u3", OrderConstant.HAS_FINISHED));
  13.     }
  15.     // 获取所有订单
  16.     public List<OrderVo> listOrders() {
  18.         // 初始化订单
  19.         init();
  21.         List<TabOrder> orderList = getOrderList();
  22.         List<OrderVo> orderVos = new ArrayList<>();
  24.         if (null == orderList || orderList.size() < 0) {
  26.             return orderVos;
  27.         }
  29.         for (TabOrder tabOrder : orderList) {
  31.             OrderVo orderVo = new OrderVo();
  33.             orderVo.setsId(tabOrder.getsId());
  34.             orderVo.setUserId(tabOrder.getUserId());
  35.             if (tabOrder.getiStatus().equals(OrderConstant.NO_PAID)) {
  37.                 orderVo.setStatus(OrderConstant.MSG_NO_PAID);
  38.             } else if (tabOrder.getiStatus().equals(OrderConstant.HAS_FINISHED)) {
  40.                 orderVo.setStatus(OrderConstant.MSG_HAS_FINISHED);
  41.             } else if (tabOrder.getiStatus().equals(OrderConstant.TO_EVALUATE)) {
  43.                 orderVo.setStatus(OrderConstant.MSG_TO_EVALUATE);
  44.             }
  45.             orderVos.add(orderVo);
  46.         }
  47.         return orderVos;
  48.     }
  50.     public List<TabOrder> getOrderList() {
  52.         return orderList;
  53.     }
  54. }

上述代码：查询出所有订单列表，然后存储在 TabOrder 类集合中，然后转换为 OrderVo 类集合，返回给前端。

获取到订单状态后，会进行状态转化：

  1. for (TabOrder tabOrder : orderList) {
  3.     OrderVo orderVo = new OrderVo();
  5.     orderVo.setsId(tabOrder.getsId());
  6.     orderVo.setUserId(tabOrder.getUserId());
  8.     // 订单状态转换
  9.     if (tabOrder.getiStatus().equals(OrderConstant.NO_PAID)) {
  11.         orderVo.setStatus(OrderConstant.MSG_NO_PAID);
  12.     } else if (tabOrder.getiStatus().equals(OrderConstant.HAS_FINISHED)) {
  14.         orderVo.setStatus(OrderConstant.MSG_HAS_FINISHED);
  15.     } else if (tabOrder.getiStatus().equals(OrderConstant.TO_EVALUATE)) {
  17.         orderVo.setStatus(OrderConstant.MSG_TO_EVALUATE);
  18.     }
  19.     orderVos.add(orderVo);
  20. }

对应数据库的字段的实体类：

  1. public class TabOrder {
  3.     // 主键
  4.     private String sId;
  5.     // 用户id
  6.     private String userId;
  7.     // 订单状态
  8.     private Integer iStatus;
  10.     // getter/setter/toString
  11. }

返回给前端的 Vo 类：

  1. public class OrderVo {
  3.     private String sId;
  4.     private String userId;
  5.     private String status;
  7.     // getter/setter/toString
  8. }

TabOrder 和 OrderVo的区别：TabOrder 中的订单状态使用数值型表示，而 OrderVo 类中的订单状态使用中文表示。

那么，上述使用常量的缺点：代码臃肿、不易维护。常量类中既记录了订单状态数值，又记录了订单状态中文描述；在业务逻辑层中还要对订单状态进行判断，然后才能转换为对应的中文描述。如果新增了一个订单状态，那么，改动就稍微有点大了。不仅要改动常量类，还要改动业务逻辑层。

那么，使用了枚举类之后呢？

首先，增加一个订单状态枚举类：

  1. public enum OrderStatusEnum {
  3.     UNKNOW(0, "未知")
  4.     ,
  5.     NO_PAID(1, "未付款")
  6.     ,
  7.     HAS_FINISHED(2, "已完成")
  8.     ,
  9.     TO_EVALUATE(3, "待评价")
  10.     ;
  12.     private Integer status;
  13.     private String desc;
  15.     OrderStatusEnum(Integer status, String desc) {
  17.         this.status = status;
  18.         this.desc = desc;
  19.     }
  21.     // 根据订单状态获取订单枚举类型
  22.     public static OrderStatusEnum getOrderStatusEnumByStatus(Integer status) {
  24.         OrderStatusEnum[] values = OrderStatusEnum.values();
  25.         if (null == values || values.length < 1) {
  27.             return OrderStatusEnum.UNKNOW;
  28.         }
  30.         for (OrderStatusEnum value : values) {
  32.             if (value.getStatus().equals(status)) {
  34.                 return value;
  35.             }
  36.         }
  37.         return OrderStatusEnum.UNKNOW;
  38.     }
  40.     // getter
  41. }

然后，修改业务逻辑层代码（只修改 for 循环语句）:

  1. for (TabOrder tabOrder : orderList) {
  3.     OrderVo orderVo = new OrderVo();
  5.     orderVo.setsId(tabOrder.getsId());
  6.     orderVo.setUserId(tabOrder.getUserId());
  8.     OrderStatusEnum orderStatusEnum = OrderStatusEnum.getOrderStatusEnumByStatus(tabOrder.getiStatus());
  9.     orderVo.setStatus(orderStatusEnum.getDesc());
  11.     orderVos.add(orderVo);
  12. }

这样，依旧可以达到相同的效果。可见，使用枚举类型确实可以简化代码开发。

但是，并不是所有的常量都可以使用枚举进行替换！！只是针对某一类场景确实是至关重要的：常量之间存在关联关系。如：订单状态的数值型与中文描述。此时，使用枚举能大大简化我们的工作

那么，为什么不可以用枚举替换所有的常量呢？枚举用起来多方便啊

在 Java 官方文档中有提到，不建议使用枚举：

Enums often require more than twice as much memory as static constants. You should strictly avoid using enums on Android.

大致意思：使用枚举会比使用静态变量多消耗两倍的内存。

为什么枚举会占内存？

简单来说：通过反编译后，枚举类型转化为一个类，会帮我们生成两个属性（name、ordinal）、枚举实例、声明了一个枚举对象的数组。而使用常量，只会占用数据类型对应的字节 * 常量个数。这样一对比，枚举占用内存的大小比静态变量多得多。Java 枚举(enum) 详解7种常见的用法 原理 枚举占用内存的原因。

所以，最后到底用不用枚举？在实际开发中，还需要根据实际使用场景去斟酌，杜绝滥用。

用法二：switch 语句（JDK 1.6）

JDK1.6 之前的 switch 语句只支持 int、char、
JDK1.6，switch 语句支持 enum 类型。使用枚举，能让我们的代码可读性更强。

  1. public enum SeasonEnum {
  3.     SPRING,
  4.     SUMMER,
  5.     AUTUMN,
  6.     WINTER;
  7. }
  9. public class TestEnum {
  12.     // 判断是否是四季
  13.     public void judgeSeason(SeasonEnum seasonEnum) {
  15.         switch (seasonEnum) {
  17.             case SPRING:
  18.                 System.out.println("这是春天");
  19.                 break;
  20.             case SUMMER:
  21.                 System.out.println("这是夏天");
  22.                 break;
  23.             case AUTUMN:
  24.                 System.out.println("这是秋天");
  25.                 break;
  26.             case WINTER:
  27.                 System.out.println("这是冬天");
  28.                 break;
  29.             default:
  30.                 System.out.println("这是错误的季节");
  31.         }
  32.     }
  34.     public static void main(String[] args) {
  36.         TestEnum testEnum = new TestEnum();
  37.         SeasonEnum spring = SeasonEnum.SPRING;
  39.         testEnum.judgeSeason(spring);
  40.     }
  41. }

用法三：抽象方法

定义一个含有抽象方法的枚举类：

  1. public enum OrderEnum {
  4.     // 未付款
  5.     NO_PAID(1) {
  7.         @Override
  8.         public String getOrderStatus() {
  10.             return "未付款";
  11.         }
  12.     }
  13.     ,
  14.     // 已完成
  15.     HAS_FINISHED(2) {
  17.         @Override
  18.         public String getOrderStatus() {
  20.             return "已完成";
  21.         }
  22.     }
  23.     ,
  24.     // 待评价
  25.     TO_EVALUATE(3) {
  27.         @Override
  28.         public String getOrderStatus() {
  30.             return "待评价";
  31.         }
  32.     };
  34.     private Integer code;
  36.     OrderEnum(Integer code) {
  38.         this.code = code;
  39.     }
  41.     public abstract String getOrderStatus();
  42. }

测试：

  1. public class Test {
  4.     public static void main(String[] args) {
  6.         OrderEnum orderEnum = OrderEnum.NO_PAID;
  7.         String orderStatus = orderEnum.getOrderStatus();
  8.         System.out.println(orderStatus);
  10.         orderEnum = OrderEnum.HAS_FINISHED;
  11.         orderStatus = orderEnum.getOrderStatus();
  12.         System.out.println(orderStatus);
  13.     }
  14. }

用法四：实现接口

定义一个公共的接口，用来返回枚举中的属性的值

  1. public interface IErrorCode<K, V, T extends Enum> {
  3.     // 返回一个枚举
  4.     T get();
  5.     // 返回状态码
  6.     K getCode();
  7.     // 返回信息
  8.     V getMsg();
  9. }

定义一个状态码的枚举类

  1. public enum CodeStatusEnum implements IErrorCode<Integer, String, CodeStatusEnum> {
  4.     EMPTY_PARAM(1001, "参数为空")
  5.     ,
  6.     ERROR_PARAM(1002, "参数错误")
  7.     ,
  8.     EMPTY_OBJECT(1003, "对象为空")
  9.     ;
  11.     private Integer code;
  12.     private String msg;
  14.     CodeStatusEnum(Integer code, String msg) {
  16.         this.code = code;
  17.         this.msg = msg;
  18.     }
  20.     @Override
  21.     public CodeStatusEnum get() {
  23.         return this;
  24.     }
  25.     @Override
  26.     public Integer getCode() {
  28.         return code;
  29.     }
  31.     @Override
  32.     public String getMsg() {
  34.         return msg;
  35.     }
  36. }

定义一个订单状态的枚举类

  1. public enum OrderStatusEnum implements IErrorCode<Integer, String, CodeStatusEnum> {
  3.     UNKNOW(0, "未知")
  4.     ,
  5.     NO_PAID(1, "未付款")
  6.     ,
  7.     HAS_FINISHED(2, "已完成")
  8.     ,
  9.     TO_EVALUATE(3, "待评价")
  10.     ;
  12.     private Integer status;
  13.     private String desc;
  15.     OrderStatusEnum(Integer code, String msg) {
  17.         this.code = code;
  18.         this.msg = msg;
  19.     }
  21.     @Override
  22.     public CodeStatusEnum get() {
  24.         return this;
  25.     }
  27.     @Override
  28.     public Integer getCode() {
  30.         return code;
  31.     }
  33.     @Override
  34.     public String getMsg() {
  36.         return msg;
  37.     }
  38. }

测试：

  1. public class Test {
  4.     public static void test(IErrorCode iErrorCode) {
  6.         if (iErrorCode.get() == CodeStatusEnum.EMPTY_OBJECT) {
  8.             System.out.println(MessageFormat.format("key: {0}, value: {1}", iErrorCode.getCode(), iErrorCode.getMsg()));
  9.         }
  10.     }
  12.     public static void main(String[] args) {
  14.         IErrorCode<Integer, String, CodeStatusEnum> iErrorCode = CodeStatusEnum.EMPTY_OBJECT;
  15.         test(iErrorCode);
  16.     }
  17. }

总结：项目中使用同一接口管理枚举类， 在方法参数中使用接口而不是用具体的枚举对象作为入参， 可以一定程度上降低程序的耦合性

另外一种用法：提取一个公共的方法，通过code获取其msg

  1. public class EnumUtil {
  4.     public static <T extends ICode> T getByCode(Integer code, Class<T> enumClass) {
  6.         if (code != null) {
  8.             for (T each : enumClass.getEnumConstants()) {
  10.                 if (code.equals(each.getCode())) {
  12.                     return each;
  13.                 }
  14.             }
  15.         }
  16.         throw new RuntimeException("没有可匹配的code：" + code);
  17.     }
  18. }

用法五：接口组织枚举

  1. interface Food {
  4.     enum Appetizer implements Food {
  6.         SALAD, SOUP, SPRING_ROLLS;
  7.     }
  9.     enum MainCourse implements Food {
  11.         LASAGNE, BURRITO, PAD_THAI,
  12.         LENTILS, HUMMOUS, VINDALOO;
  13.     }
  15.     enum Dessert implements Food {
  17.         TIRAMISU, GELATO, BLACK_FOREST_CAKE,
  18.         FRUIT, CREME_CARAMEL;
  19.     }
  20. }
  22. public class InterfaceOrganizeEnum {
  24.     public static void main(String[] args) {
  26.         Food food = Appetizer.SALAD;
  27.         food = MainCourse.LASAGNE;
  28.     }
  29. }

暂不知道这个用法的使用场景。

===========================================================================================
2021-12-09 更：

用法六：枚举里面定义一个抽象方法

优化前：

  1. Integer personType = 2;
  2. if (-1 == personType) {
  4.     // TODO
  5. } else if (1 == personType) {
  7.     // TODO
  8. } else if (2 == personType) {
  10.     // TODO
  11. }

优化后：

  1. public enum PersonEnum {
  4.     ERROR(-1) {
  6.         @Override
  7.         public void doSomething() {
  9.             System.out.println("ERROR");
  10.         }
  11.     }
  12.     ,
  13.     CHILDREN(1) {
  15.         @Override
  16.         public void doSomething() {
  18.             System.out.println("哭哭哭");
  19.         }
  20.     }
  21.     ,
  22.     ADULT(2) {
  24.         @Override
  25.         public void doSomething() {
  27.             System.out.println("挣挣挣");
  28.         }
  29.     }
  30.     ,
  31.     OLD(3) {
  33.         @Override
  34.         public void doSomething() {
  36.             System.out.println("走走走");
  37.         }
  38.     }
  39.     ;
  41.     public static PersonEnum getPersonEnumByType(Integer iPersonType) {
  43.         PersonEnum[] values = PersonEnum.values();
  44.         if (null == values || values.length == 0) {
  46.             return PersonEnum.ERROR;
  47.         }
  48.         for (PersonEnum personEnum : values) {
  50.             if (personEnum.getiPersonType().equals(iPersonType)) {
  52.                 return personEnum;
  53.             }
  54.         }
  55.         return PersonEnum.ERROR;
  56.     }
  58.     private Integer iPersonType;
  60.     PersonEnum(Integer iPersonType) {
  62.         this.iPersonType = iPersonType;
  63.     }
  65.     // 抽象方法
  66.     public abstract void doSomething();
  68.     public Integer getiPersonType() {
  70.         return iPersonType;
  71.     }
  72. }

测试：

  1. public class PersonEnumTest {
  4.     public static void main(String[] args) {
  6.         Integer personType = -1;
  7.         PersonEnum.getPersonEnumByType(personType).doSomething();
  8.     }
  10. }

发表评论

表情：
评论列表 （有 0 条评论，68人围观）

还没有评论，来说两句吧...

相关阅读

    相关 enum枚举用法

    JDK1.5引入了新的类型——枚举。在 Java 中它虽然算个“小”功能，却给我的开发带来了“大”方便。 大师兄我又加上自己的理解，来帮助各位理解一下。 用法一：常量

    蔚落蔚落/ 0 赞/ 253 阅读