关于项目中状态定义优化

Posted 2021-12-01 gang-bryant

原来项目中状态是用常量来定义

代码：

1 　　public final static int POI_PROBLEM_TASK_ERROR = 4110;
2     public final static int POI_PROBLEM_COMPANY_ERROR = 4120;
3     public final static int POI_PROBLEM_CHECK_DATE_ERROR = 4130;
4     public final static int POI_PROBLEM_CHECK_ITEM_ERROR = 4140;
5     public final static int POI_PROBLEM_TASK_AND_PROCESS_ERROR = 4150;
6     public final static int POI_PROBLEM_DESCRIPTION_ERROR = 4160;
7     public final static int POI_PROBLEM_RESPONSE_PERSON_ERROR = 4170;
8     public final static int POI_PROBLEM_UNKNOWN_ERROR = 4200;
9     public final static int POI_PROBLEM_EMPTY_FIRST = 4300;

这么做的缺点有：

1.代码冗余过大

2.因为使用的数字而不是使用类型，表意不清晰

 

enum（枚举）

enum是java一种类型，适合于刚刚的业务场景

看看Enmu的java源码

 1 public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
 2  private final String name;//enmu名称
 3 public final String name() {
 4         return name;
 5     }
 6  private final int ordinal;//枚举中声明位置
 7  public final int ordinal() {
 8         return ordinal;
 9     }
10 protected Enum(String name, int ordinal) {//构造函数
11         this.name = name;
12         this.ordinal = ordinal;
13     }
14  public String toString() {
15         return name;
16     }
17 public final boolean equals(Object other) {//比较是否是同一个对象
18         return this==other;
19     }
20 public final int hashCode() {
21         return super.hashCode();//计算hash值
22     }
23  protected final Object clone() throws CloneNotSupportedException {
24         throw new CloneNotSupportedException();
25     }
26 public final int compareTo(E o) {//实现compare接口，比较枚举位置
27         Enum<?> other = (Enum<?>)o;
28         Enum<E> self = this;
29         if (self.getClass() != other.getClass() && // optimization
30             self.getDeclaringClass() != other.getDeclaringClass())
31             throw new ClassCastException();
32         return self.ordinal - other.ordinal;
33     }

看过源码可以大概了解enum的工作原理，

有一个name记录当前枚举的名字，有一个ordinal记录了枚举的位置

比较两个enum其实比较的是两个enum的位置。

 

通过查阅资料发现：

创建枚举类型要使用 enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类（java.lang.Enum 是一个抽象类）。
枚举类型符合通用模式 Class Enum<E extends Enum<E>>，而 E 表示枚举类型的名称。
枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal) 构造函数中(默认构造函数)。
在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了此设置被创建的顺序。

个人理解：

使用 enum继承 java.lang.Enum类似于使用class默认继承了java.lang.Object

Enum<E extends Enum<E>> 表示泛型参数就是自己

变成代码就是类似于这样的
public class Test extends Enum<Test>

因为在 java 编译器上进行了限制，所以java.lang.Enum 抽象类是不能在代码中进行 extends 

每个枚举都是枚举类的对象，通过Enum(String name, int ordinal) 构造函数构造。

 

我们使用枚举改造下刚才的代码

 1 public enum CodeStatus {
 2     POI_PROBLEM_TASK_ERROR(4110),//对象1
 3     POI_PROBLEM_COMPANY_ERROR(4120),//对象2
 4     POI_PROBLEM_CHECK_DATE_ERROR(4130),
 5     POI_PROBLEM_CHECK_ITEM_ERROR(4140),
 6     POI_PROBLEM_TASK_AND_PROCESS_ERROR(4150),
 7     POI_PROBLEM_DESCRIPTION_ERROR(4160),
 8     POI_PROBLEM_RESPONSE_PERSON_ERROR(4170),
 9     POI_PROBLEM_UNKNOWN_ERROR(4200),
10     POI_PROBLEM_EMPTY_FIRST(4300);
11 
12     private int code;
13 
14     CodeStatus(int code) {
15         this.code = code;
16     }
17 
18     public int getCode() {
19         return code;
20     }
21 }

每次创建一个对象都包含一个操作

1 new Enum<CodeStatus >(name,ordinal);

 

 

测试代码

1 CodeStatus.POI_PROBLEM_TASK_ERROR.getCode()

 

使用enum优点

1. 枚举写法简单（代码冗余减少，类型清晰）

2. 枚举自己处理序列化

3.枚举实例创建是thread-safe(线程安全的)

当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的。所以，创建一个enum类型是线程安全的。

（类似于单例模式中的饿汉模式的解决方法）