使用枚举实现“状态”转换限制

枚举类

JDK5 提供了一种新的特殊的类——枚举类，一般在类对象有限且固定的场景下使用，用来替代类中定义常量的方式。枚举相较于常量更加直观且类型安全。

枚举类的使用非常简单，用 enum 关键字来定义，多个枚举变量直接用逗号隔开。先来定义一个简单的枚举类 OrderStatus.java

1. public enum OrderStatus {
2.    //未支付、已支付、退款中、退款成功、退款失败；
3.    NO_PAY, PAY, REFUNDING, REFUNDED, FAIL_REFUNDED, ;
4. }

在其他类中使用 enum 变量的时候，只需要【类名.变量名】就可以了，和使用静态变量一样。另外，枚举类型可以确保 JVM 中仅存在一个常量实例，所以可以放心的使用“ ==”来比较两个变量。

注意事项：

1. 枚举类的第一行必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其它的东西，这个分号就不能省略。建议不要省略！
2. 枚举变量最好大写，多个单词之间使用“_”隔开（比如：NO_PAY）。
   反编译
   可以先通过 javac 命令或者 IDEA 的编译功能将OrderStatus.java 编译为OrderStatus.class 字节码文件，然后用DJ Java Decompiler 反编译器对 .class 文件进行反编译。

1. public final class OrderStatus extends Enum
2. {
4. //该方法会返回包括所有枚举变量的数组，可以方便的用来做循环。
5. public static OrderStatus[] values()
6. {
7.     return (OrderStatus[])$VALUES.clone();
8. }
10. //根据传入的字符串，转变为对应的枚举变量。
11. //前提是传的字符串和定义枚举变量的字符串一抹一样，区分大小写。
12. //如果传了一个不存在的字符串，那么会抛出异常。
13. public static OrderStatus valueOf(String name)
14. {
15.     return (OrderStatus)Enum.valueOf(com/itcast/java/enumpack/OrderStatus, name);
16. }
18. private OrderStatus(String s, int i)
19. {
20.     super(s, i);
21. }
23. public static final OrderStatus NO_PAY;
24. public static final OrderStatus PAY;
25. public static final OrderStatus REFUNDING;
26. public static final OrderStatus REFUNDED;
27. public static final OrderStatus FAIL_REFUNDED;
28. private static final OrderStatus $VALUES[];
30. static
31. {
32.     NO_PAY = new OrderStatus("NO_PAY", 0);
33.     PAY = new OrderStatus("PAY", 1);
34.     REFUNDING = new OrderStatus("REFUNDING", 2);
35.     REFUNDED = new OrderStatus("REFUNDED", 3);
36.     FAIL_REFUNDED = new OrderStatus("FAIL_REFUNDED", 4);
37.     $VALUES = (new OrderStatus[] {
38.         NO_PAY, PAY, REFUNDING, REFUNDED, FAIL_REFUNDED
39.     });
40. }
41. }

3. 如源码所示：

• 编译器会自动创建一个 final 类型的类继承 Enum 类，所以枚举类不能被继承。
• 会自动生成私有构造方法，当然也可以定义构造方法，但必须是私有的，这样就不能在别处声明此类的对象了。
• 枚举项会被自动添加 public static final 修饰，并定义为 OrderStatus 类型，并在静态代码块中被初始化。
• 并提供了 values() 和 valueOf(String name) 的静态方法。

定义的枚举变量实际上是编译器自动生成了构造函数。

所有枚举类都是 Enum 的子类，枚举类可以实现一个或多个接口。

Enum

Enum 是所有 Java 语言枚举类型的公共基类，实现了 Comparable 和 Serializable 接口。它包含 final 类型的 name 和 ordinal （此枚举常量的序号，从0开始）属性，下面来了解下它的方法

• protected Enum(String name, int ordinal);——构造方法；
• public String toString();——返回 name 字段，即枚举定义枚举变量的字符串；
• protected final Object clone();——抛出 CloneNotSupportedException 异常，保证枚举类永远不会被克隆；
• public final ClassgetDeclaringClass();——返回与此枚举常量的枚举类型对应的类对象；
• protected final void finalize();—— 枚举类不能有 finalize 方法；
• readObject(ObjectInputStream in);&readObjectNoData();—— 抛出InvalidObjectException 异常，防止默认反序列化； 扩展
  

1. 枚举类中可以自定义属性自定义的属性值最好用 private final 修饰，防止生成的 set 方法在使用时修改属性值，使代码更加安全。
2. 枚举类中可以自定义构造函数构造函数必须为 private 修饰，防止在别处声明此类对象。
3. 枚举类可以自定义方法，枚举项可以选择性覆盖自定义的方法。 ```java public enum OrderStatus{ NO_PAY(“未支付”,0), PAY(“已支付”,1){

1. @Override
2. public void printOrderStatus() {
3.     System.out.println("已支付");
4. }

4. }, REFUNDING(“退款中”,2), REFUNDED(“退款成功”,3), FAIL_REFUNDED(“退款失败”,4), ;
   private final String name; private final int status;
   private OrderStatus(String name,int status){

1. this.name = name;
2. this.status = status;

5. }
   public void printOrderStatus(){

1. System.out.println("打印订单状态");

6. } }

public class EnumTest { public static void main(String[] args) { OrderStatus.PAY.printOrderStatus(); OrderStatus.NO_PAY.printOrderStatus(); } }

1. ![2021-09-15-14-20-13-906674.png](https://cdn.nlark.com/yuque/0/2021/png/396745/1631686837519-0da4ad7a-7f02-426b-b527-74a019ce512c.png#clientId=u5f62019f-13c2-4&from=ui&id=u0c5fd862&margin=%5Bobject%20Object%5D&name=2021-09-15-14-20-13-906674.png&originHeight=111&originWidth=619&originalType=binary&ratio=1&size=8193&status=done&style=none&taskId=u71dcecc7-4898-4b44-b2fd-aa77e60205c)<br />枚举类也可以有抽象方法，但是枚举项必须重写该方法。
3. 1. 枚举类实现接口与普通类一样，实现接口的时候需要实现接口的抽象方法，也可以让枚举类的不同对象实现不同的行为。
5. 例
6. ```java
7. //定义一个接口
8. public interface Order {
9.    void printOrderStatus();
10. }
12. //枚举类实现该接口
13. public enum OrderStatus implements Order{
14.    NO_PAY("未支付",0){
15.        @Override
16.        public void printOrderStatus() {
17.            System.out.println("未支付");
18.        }
19.    },
20.    PAY("已支付",1){
21.        @Override
22.        public void printOrderStatus() {
23.            System.out.println("已支付");
24.        }
25.    },
26.    REFUNDING("退款中",2){
27.        @Override
28.        public void printOrderStatus() {
29.            System.out.println("退款中");
30.        }
31.    },
32.    REFUNDED("退款成功",3){
33.        @Override
34.        public void printOrderStatus() {
35.            System.out.println("退款成功");
36.        }
37.    },
38.    FAIL_REFUNDED("退款失败",4){
39.        @Override
40.        public void printOrderStatus() {
41.            System.out.println("退款失败");
42.        }
43.    },
44.    ;
46.    private final String name;
47.    private final int status;
49.    private OrderStatus(String name,int status){
50.        this.name = name;
51.        this.status = status;
52.    }
53. }

此时查看编译后的文件，会发现除了生成 OrderStatus.class 文件之外，还生成了多个 .class 文件：

它们是 OrderStatus.class 中生成的匿名内部类的文件。

状态转换

需求

订单是电商项目中不可缺少的组成部分，而订单状态的转换也是经常讨论的问题。都知道订单状态的转换是有一定的逻辑性的，不可以随意转换。

例：购买某个商品，只是把它加入了购物车，此时应该是未支付状态。如果来个请求想把它转换为退款状态，那么系统应该抛出提示信息“状态转换失败，请先完成购买！”

接下来就用枚举来完成一下订单状态转换的限制。

实现

枚举类定义：

1. public enum OrderStatus{
2.    NO_PAY("未支付",0){
3.        @Override
4.        public Boolean canChange(OrderStatus orderStatus) {
5.            switch (orderStatus){
6.                case PAY:
7.                    return true;
8.                default:
9.                    return false;
10.            }
11.        }
12.    },
13.    PAY("已支付",1){
14.        @Override
15.        public Boolean canChange(OrderStatus orderStatus) {
16.            //因为退款接口一般都会有延迟，所以会先转化为“退款中”状态
17.            switch (orderStatus){
18.                case REFUNDING:
19.                    return true;
20.                default:
21.                    return false;
22.            }
23.        }
24.    },
25.    REFUNDING("退款中",2){
26.        @Override
27.        public Boolean canChange(OrderStatus orderStatus) {
28.            switch (orderStatus){
29.                case REFUNDED:
30.                case FAIL_REFUNDED:
31.                    return true;
32.                default:
33.                    return false;
34.            }
35.        }
36.    },
37.    REFUNDED("退款成功",3),
38.    FAIL_REFUNDED("退款失败",4),
39.    ;
41.    private final String name;
42.    private final int status;
44.    private OrderStatus(String name,int status){
45.        this.name = name;
46.        this.status = status;
47.    }
49.    //自定义转换方法
50.    public Boolean canChange(OrderStatus orderStatus){
51.        return false;
52.    }
53. }

调用方法：

1. public class EnumTest {
3.    public static void main(String[] args) {
4.        Boolean aBoolean = OrderStatus.NO_PAY.canChange(OrderStatus.PAY);
5.        String statusStr = aBoolean?"可以":"不可以";
6.        System.out.println("是否可以完成状态转换："+ statusStr);
8.        Boolean flag = OrderStatus.REFUNDED.canChange(OrderStatus.FAIL_REFUNDED);
9.        String flagStr = flag?"可以":"不可以";
10.        System.out.println("是否可以完成状态转换："+ flagStr);
11.    }
12. }

返回结果：

这样就用枚举类实现了订单状态转换的限制。此例子只是为状态转换提供一种思路，具体的流程还需要根据自己系统中的业务来具体处理。