基础

在 JDK 1.5 之前没有枚举类型，那时候一般用接口常量来替代。我们现在常常使用枚举类来代替一系列类似属性的常量，这么做有什么好吃呢？将这个问题扩张一下，枚举类到底有什么用呢？

以这种方式定义的常量使代码更具可读性，预先记录可接受值的列表，并避免由于传入无效值而引起的意外行为；

同时，在程序中经常使用到的重复的值，都应该将这些重复内容与程序进行解耦；

枚举类是单例的，保证线程安全也让程序省下了不少内存

以下声明了一个普通的枚举类

public enum SexEnums {
    FAMALE,
    MALE;
}
1
2
3
4

之后便可以通过枚举类型名直接引用常量，如 SexEnums.MALE。枚举类的每个成员都是枚举类型，因此可以使用枚举还可以使 switch 语句的可读性更强

Java 中的每一个枚举都继承自 java.lang.Enum 类。当定义一个枚举类型时，每一个枚举类型成员都可以看作是 Enum 类的实例，这些枚举成员默认都被 final、public, static 修饰，当使用枚举类型成员时，直接使用枚举名称调用成员即可

你可以将枚举类当成一个普通的java类，为其添加方法。由于枚举类在程序中是单例的，我们应该私有化构造方法让它保持单例，如果类中包含了一些内容，我们应该让用户能访问到，因此一个普通的枚举类应该长以下这样

public enum SexEnums {
    FAMALE(0),
    MALE(1);

    private final Integer integer;

    private SexEnums(Integer i) {
        this.integer = i;
    }

    public Integer getInteger() {
        return integer;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

EnumMap 与 EnumSet

EnumMap 是专门为枚举类型量身定做的 Map 实现。虽然使用其他的 Map（如 HashMap）实现也能完成枚举类型实例到值的映射，但是使用 EnumMap 会更加高效。

HashMap 只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以 EnumMap 使用数组来存放与枚举类型对应的值，使得 EnumMap 的效率非常高

public enum DataBaseType {
    MYSQUORACLE,DB2,SQLSERVER
}
// 某类中定义的获取数据库URL的方法以及EnumMap的声明
private EnumMap<DataBaseType,String>urls = new EnumMap<DataBaseType,String>(DataBaseType.class);
public DataBaseInfo() {
    urls.put(DataBaseType.DB2,"jdbc:db2://localhost:5000/sample");
    urls.put(DataBaseType.MYSQL,"jdbc:mysql://localhost/mydb");
    urls.put(DataBaseType.ORACLE,"jdbc:oracle:thin:@localhost:1521:sample");
    urls.put(DataBaseType.SQLSERVER,"jdbc:microsoft:sqlserver://sql:1433;Database=mydb");
}
//根据不同的数据库类型，返回对应的URL
// @param type DataBaseType 枚举类新实例
// @return
public String getURL(DataBaseType type) {
    return this.urls.get(type);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

虽然直接在枚举类中赋值也能实现相同操作，但在实际使用中，EnumMap 对象 urls 往往是由外部负责整个应用初始化的代码来填充的

EnumSet 是抽象类，其有两个实现：RegularEnumSet 、JumboEnumSet，选择哪一个取决于实例化时枚举中常量的数量

在很多场景中的枚举常量集合操作（如：取子集、增加、删除、containsAll和removeAll批操作）使用EnumSet非常合适；如果需要迭代所有可能的常量则使用Enum.values()

原理

下面来说说枚举的原理

像Java在1.5中引入的很多特性，为了向后兼容，编译器会帮我们写的源代码做很多事情，比如泛型为什么会擦除类型，为什么会生成桥接方法，foreach迭代，自动装箱/拆箱等，这有个术语叫“语法糖”，而编译器的特殊处理叫“解语法糖”，这么做主要是为了为我们省去许多重复操作。那么像枚举也是在JDK1.5中才引入的，又是怎么实现的呢？

来看看一个普通的枚举与其反编译的基本信息

public enum Operator {
 
    ADD,
    SUBTRACT,
    MULTIPLY,
    DIVIDE
 
}
1
2
3
4
5
6
7
8

localhost:mikan mikan$ javap Operator.class
Compiled from "Operator.java"
public abstract class com.mikan.Operator extends java.lang.Enum<com.mikan.Operator> {
  public static final com.mikan.Operator ADD;
  public static final com.mikan.Operator SUBTRACT;
  public static final com.mikan.Operator MULTIPLY;
  public static final com.mikan.Operator DIVIDE;
  public static com.mikan.Operator[] values();
  public static com.mikan.Operator valueOf(java.lang.String);
  public java.lang.String getOperator();
  com.mikan.Operator(java.lang.String, int, java.lang.String, com.mikan.Operator$1);
  static {};
}
1
2
3
4
5
6
7
8
9
10
11
12
13

我们虽然没有让该类继承Enum，但是在编译后编译器自动让该类继承了Enum，因此java.lang.Enum抽象类是所有枚举类型基类

可以看到所有的字段已经加上了public static final，同时生成了四个内部类 Operator ，因此枚举中定义的每一个属性都是一个内部类，这样就解释了为什么每一个属性都是枚举类型

方法values()就是用来返回所有定义的枚举常量，valueOf(String)是一个公共的静态方法，所以我们可以直接调用该方法，返回参数字符串表示的枚举常量

java 为每个枚举都定义了两个属性，name和ordinal，name表示我们定义的枚举常量的名称，如ADD、SUBTRACT等，而ordinal是一个顺序号，根据定义的顺序分别赋予一个整形值，从0开始，因此该枚举对象可以调用name与ordinal方法

统一结果返回

枚举类已经做entity的属性，比如性别，星期等，都是更多的应用则是做统一结果返回

统一返回数据格式没有固定的格式，只要能描述清楚返回的数据状态以及要返回的具体数据就可以。但是一般会包含状态码、返回消息、数据这几部分内容

结果状态码

public enum ResultCode{

    SUCCESS(1000, "成功"),
    RESOURCE_NOT_FOUND(1001, "未找到该资源"),
    REQUEST_VALIDATION_FAILED(1002, "请求数据格式验证失败");
    private final int code;

    private final String message;

    private ResultCode(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }

    @Override
    public String toString() {
        return"ResultCode{" +
                "code=" + code +
                ", message='" + message +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

全局统一返回结果

@Setter
public class R {

    private Boolean success;

    private Integer code;

    private String message;

    private Map<String, Object> data = new HashMap<String, Object>();

    private R(){}

    public static R ok(){
        R r = new R();
        r.setSuccess(true);
        r.setCode(ResultCode.SUCCESS.getCode());
        r.setMessage(ResultCode.SUCCESS.getMessage());
        return r;
    }

    public static R fail(BaseException exception){
        R r = new R();
        r.setSuccess(false);
        r.setCode(exception.getResultCode().getCode());
        r.setMessage(exception.getResultCode().getMessage());
        return r;
    }

    public R setData(String key, Object value){
        this.data.put(key, value);
        return this;
    }

    public R setData(Map<String, Object> map){
        this.setData(map);
        return this;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

这里的BaseException

@Getter
public abstract class BaseException extends RuntimeException {

    private final ResultCode resultCode;
    private final Map<String, Object> data = new HashMap<>();


    public BaseException(ResultCode resultCode, Map<String, Object> data) {
        super(resultCode.getMessage());
        this.resultCode = resultCode;
        if (!ObjectUtils.isEmpty(data)) {
            this.data.putAll(data);
        }
    }

    protected BaseException(ResultCode resultCode, Map<String, Object> data, Throwable cause) {
        super(resultCode.getMessage(), cause);
        this.resultCode = resultCode;
        if (!ObjectUtils.isEmpty(data)) {
            this.data.putAll(data);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

抽象类的继承类

public class ResourceNotFoundException extends BaseException{

    public ResourceNotFoundException(ResultCode resultCode, Map<String, Object> data) {
        super(ResultCode.RESOURCE_NOT_FOUND, data);
    }
}
1
2
3
4
5
6