关于项目中状态定义优化

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

代码：

　　public final static int POI_PROBLEM_TASK_ERROR = 4110;
    public final static int POI_PROBLEM_COMPANY_ERROR = 4120;
    public final static int POI_PROBLEM_CHECK_DATE_ERROR = 4130;
    public final static int POI_PROBLEM_CHECK_ITEM_ERROR = 4140;
    public final static int POI_PROBLEM_TASK_AND_PROCESS_ERROR = 4150;
    public final static int POI_PROBLEM_DESCRIPTION_ERROR = 4160;
    public final static int POI_PROBLEM_RESPONSE_PERSON_ERROR = 4170;
    public final static int POI_PROBLEM_UNKNOWN_ERROR = 4200;
    public final static int POI_PROBLEM_EMPTY_FIRST = 4300;

这么做的缺点有：

1.代码冗余过大

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

enum（枚举）

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

看看Enmu的java源码

public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
 private final String name;//enmu名称
public final String name() {
        return name;
    }
 private final int ordinal;//枚举中声明位置
 public final int ordinal() {
        return ordinal;
    }
protected Enum(String name, int ordinal) {//构造函数
        this.name = name;
        this.ordinal = ordinal;
    }
 public String toString() {
        return name;
    }
public final boolean equals(Object other) {//比较是否是同一个对象
        return this==other;
    }
public final int hashCode() {
        return super.hashCode();//计算hash值
    }
 protected final Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }
public final int compareTo(E o) {//实现compare接口，比较枚举位置
        Enum<?> other = (Enum<?>)o;
        Enum<E> self = this;
        if (self.getClass() != other.getClass() && // optimization
            self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }

看过源码可以大概了解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) 构造函数构造。

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

public enum CodeStatus {
    POI_PROBLEM_TASK_ERROR(4110),//对象1
    POI_PROBLEM_COMPANY_ERROR(4120),//对象2
    POI_PROBLEM_CHECK_DATE_ERROR(4130),
    POI_PROBLEM_CHECK_ITEM_ERROR(4140),
    POI_PROBLEM_TASK_AND_PROCESS_ERROR(4150),
    POI_PROBLEM_DESCRIPTION_ERROR(4160),
    POI_PROBLEM_RESPONSE_PERSON_ERROR(4170),
    POI_PROBLEM_UNKNOWN_ERROR(4200),
    POI_PROBLEM_EMPTY_FIRST(4300);

    private int code;

    CodeStatus(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }
}

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

new Enum<CodeStatus >(name,ordinal);

测试代码

CodeStatus.POI_PROBLEM_TASK_ERROR.getCode()

使用enum优点

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

2. 枚举自己处理序列化

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

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

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