为什么使用枚举

最近在看公司的代码，发现公司使用到了枚举，这才让我重新拾起枚举的用法，枚举有四个方法：

方法名称	描述
values()	以数组形式返回枚举类型的所有成员
valueOf()	将普通字符串转换为枚举实例
compareTo()	比较两个枚举成员在定义时的顺序
ordinal()	获取枚举成员的索引位置

枚举的四个方法，我会在下文中讲到，现在先说为什么使用枚举。

我们在调用接口返回数据时，同时需要错误数据的状态码和描述，这时，就需要用到了枚举，我们可以在枚举定义好返回码和描述信息，供前台用户使用。

定义接口

package testEnum;

public interface BaseEnum {

	/**
     * 返回的错误代码
     *
     * @return
     */
    public String getCode();

    /**
     * 返回的中文描述
     *
     * @return
     */
    public String getChineseDesc();

    /**
     * 返回的英语描述
     *
     * @return
     */
    public String getEnglishDesc();
}

用枚举实现接口

其实，枚举就是类，我们可以在枚举当中定义构造器、属性、方法，而SUCCESS和ERROR中的参数就对应于构造器中的参数

package testenum;

/**
 * Created By zby on 21:28 2022/7/27
 * <p>
 * 结果返回值
 */
public enum ReturnCodeEnum implements BaseEnum {

    SUSSESS("000000", "success", "操作成功"),
    ERROR("100000", "error", "操作失败");

    private String code;
    private String englishDesc;
    private String chineseDesc;

    ReturnCodeEnum(String code, String englishDesc, String chineseDesc) {
        this.code = code;
        this.englishDesc = englishDesc;
        this.chineseDesc = chineseDesc;
    }

    @Override
    public String getCode() {
        return this.code;
    }

    @Override
    public String getChineseDesc() {
        return this.chineseDesc;
    }

    @Override
    public String getEnglishDesc() {
        return this.englishDesc;
    }

    /**
     * 根据参数获取返回值，将返回值以json格式的方式输出
     * <p>
     * 这里使用到了final关键字，防止type指向新的引用对象
     *
     * @param type 用户传入的枚举的参数，比如ReturnCodeEnum.SUCCESS，ReturnCodeEnum.ERROR
     * @return
     */
    public static String StringToJson(final Object type) {
        if (null == type || type.equals(""))
            return "{'code':'-100000','englishDesc':'type is null','chineseDesc':'类型为空'}";

        for (ReturnCodeEnum returnCodeEnum : ReturnCodeEnum.values()) {
            String name = returnCodeEnum.name();
            if (name.equals(type.toString())) {
                return "{'code':'" + returnCodeEnum.getCode()
                        + "','chineseDesc':'" + returnCodeEnum.getChineseDesc()
                        + "','englishDesc':'" + returnCodeEnum.getEnglishDesc()
                        + "'}";
            }
        }
        return "{'code':'-200000','englishDesc':'parameter is error ','chineseDesc':'参数类型错误'}";
    }

}

使用枚举

StringToJson方法

package testEnum;

public class Test {

	public static void main(String[] args) {
		System.out.println(ReturnCodeEnum.StringToJson(ReturnCodeEnum.ERROR));
	}
}

输出结果:
	{'code':'100000','englishDesc':'error','chineseDesc':'操作失败'}

values方法

重写toString方法

在ReturnCodeEnum.java中增加ToString（）方法

  /**
  * Created By zby on 21:45 2022/7/27
  * 重写toString方法，便于测试
  */
  @Override
  public String toString() {
      return "{'code':'" + this.getCode()
              + "','chineseDesc':'" + this.getChineseDesc()
              + "','englishDesc':'" + this.getEnglishDesc()
              + "'}";
  }

执行values方法

/**
 * Created By zby on 21:41 2022/7/27
 */
public class Test {

    public static void main(String[] args) {
		// 使用values()方法
        ReturnCodeEnum[] values = ReturnCodeEnum.values();
        for (ReturnCodeEnum value : values) {
            System.out.println(value);
        }
    }
}

输出结果: 
	{'code':'000000','chineseDesc':'操作成功','englishDesc':'success'}
	{'code':'100000','chineseDesc':'操作失败','englishDesc':'error'}

valueOf方法

package testenum;

import static testenum.ReturnCodeEnum.values;

/**
 * Created By zby on 21:41 2022/7/27
 */
public class Test {
    public static void main(String[] args) {
        ReturnCodeEnum error = ReturnCodeEnum.valueOf("ERROR");
        System.out.println(error);
    }
}

输出结果：
	{'code':'100000','chineseDesc':'操作失败','englishDesc':'error'}

compareTo方法

package testenum;

/**
 * Created By zby on 21:41 2022/7/27
 */
public class Test {
    public static void main(String[] args) {
        int i = ReturnCodeEnum.SUSSESS.compareTo(ReturnCodeEnum.ERROR);
        System.out.println(i);

        i = ReturnCodeEnum.SUSSESS.compareTo(ReturnCodeEnum.SUSSESS);
        System.out.println(i);

        i = ReturnCodeEnum.ERROR.compareTo(ReturnCodeEnum.SUSSESS);
        System.out.println(i);
    }
}

输出结果：
i --> -1
i --> 0
i --> 1

• 当返回为-1时，说明前一个枚举的顺序在后一个枚举之前
• 当返回为0时，说明这是同一个枚举
• 当返回为1时，说明前一个枚举的顺序在后一个枚举之后

ordinal方法

package testenum;

/**
 * Created By zby on 21:41 2022/7/27
 */
public class Test {
    public static void main(String[] args) {
        System.out.println("ReturnCodeEnum.SUSSESS.ordinal --> "+ReturnCodeEnum.SUSSESS.ordinal());
        System.out.println("ReturnCodeEnum.ERROR.ordinal --> " + ReturnCodeEnum.ERROR.ordinal());
    }
}

输出结果：
	ReturnCodeEnum.SUSSESS.ordinal --> 0
	ReturnCodeEnum.ERROR.ordinal --> 1

总结

枚举在我们开发中还是非常重要的，因而，我们开发经常使用枚举返回状态码和信息。