使用枚举封装常量的好处附上一个枚举的小例子

定义一个枚举类，类中存放了状态编号，和该编号对应的信息提示，枚举类中我们需要定义一个构造器，否则在定义SUCCESS、END、REPEAT_KILL、SYSTEM_ERROR等属性的时候会报错，同时我们之各state和msg变量get方法，不让外部可以修改他们的参数和设置。

在这段代码中我们发现Enum枚举类没有values()方法却可以在枚举类中的stateOf方法使用：

java编译器在对enum关键字进行处理时，实际上是将enum转换成为了java.lang.Enum类的一个子类来完成，而这个子类中含有values()静态方法。

枚举被设计成是单例模式，即枚举类型会由JVM在加载的时候，实例化枚举对象，你在枚举类中定义了多少个就会实例化多少个，JVM为了保证每一个枚举类元素的唯一实例，是不会允许外部进行new的，所以会把构造函数设计成private，防止用户生成实例，破坏唯一性。

public enum StateEnum {

    SUCCESS(1,"秒杀成功"),
    END(2,"秒杀结束"),
    REPEAT_SECKILL(3,"重复秒杀"),
    SYSTEM_ERROR(4,"系统错误");

    private int state;

    private String msg;

    public int getState() {
        return state;
    }

    public String getMsg() {
        return msg;
    }

    private StateEnum(int state, String msg) {
        this.state = state;
        this.msg = msg;
    }

    public static StateEnum stateOf(int index){

        for (StateEnum enums : values()) {
            if(enums.getState()==index){
                return enums;
            }
        }
        return null;
    }

}

定义一个实体类EnumExecution,里面存放了，id、状态编码、编码对应的信息、还有一个person类型的参数。

public class EnumExecution {

    private long id;

    private int state;

    private String msg;

    private Person person;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
//通过构造器传入stateEnum枚举对象，这个对象中存放了state、msg等属性，如果枚举是SUCCESS，则返回person
    public EnumExecution(long id, StateEnum states, Person person) {
        this.id = id;
        this.state = states.getState();
        this.msg = states.getMsg();
        this.person = person;
    }

    public EnumExecution(long id, StateEnum states) {
        this.id = id;
        this.state = states.getState();
        this.msg = states.getMsg();
    }

    @Override
    public String toString() {

        return "EnumExecution{"
                +"id:"+id
                +",state:"+state
                +",msg:"+msg
                +"}";
    }
}

测试类EnumTest：

public class EnumTest {

    public static void main(String[] args) {

        long id=1000;
        Person person=new Person("马飞", 12);
        //如果不使用枚举类型，需要这样去定义EnumExecution eex=new EnumExecution(id, 1,"秒杀成功", person);
        EnumExecution eex=new EnumExecution(id, StateEnum.SUCCESS, person);
        System.out.println(eex.getPerson().getName());
        System.out.println(eex.getMsg());
        System.out.println(eex.getState());
        System.out.println(eex.toString());

    }

}

其实在我们写出来的逻辑代码里面是不应该出现常量字符串和常量数字之类的东西。

我们返回的state和msg参数信息应该是输出给前端的，但是我们不想在我们的return代码中硬编码这两个参数，所以我们应该考虑用枚举的方式将这些常量封装起来。

在很久之后，忽然有些地方的值换了，只需要修改一处地方，整个项目都不用担心会出问题，

但是，如果你没有这么干，那么，没人知道你在逻辑代码里面还有这样的常量存在，就会造成很严重的后果。