Java枚举

前言

	枚举类型可以取代以往常量的定义方式，即将常量封装在类或接口中。同时枚举类型还赋予程序在编译时进行检查的功能。

常量

在程序运行过程中一直不会改变的量称为常量（constant），通常也被称为“final变量”。常量在整个程序中只能被赋值一次。(final 修饰的变量，第二次赋值时会报编译错误)

static final num = 1;

枚举的优势

1. 类型安全。
2. 紧凑有效的数据定义。
3. 可以和程序其他部分完美交互。
4. 运行效率高。

枚举

通常我们会在类中或接口中声明常量并赋值，以便提供在程序中使用。下面简单示例，来区分枚举和常量声明的区别。

public class ConstantDemo {
    /**
     * 类中定义常量
     */
    public static final int num1 = 1;
    public interface ConstantDemo2 {

        /**
         * 接口中定义常量
         */
        public static final int num2 = 2;
    }

    public enum ConstantDemo3 {
        /**
         * 枚举中定义常量
         */
        TYPE_N, TYPE_D;

    }
    public static void main(String[] args) {
        System.out.println("类中定义常量===" + num1);

        System.out.println("接口中定义常量===" + ConstantDemo2.num2);

        System.out.println("枚举中定义常量类型N===" + ConstantDemo3.TYPE_N);

        System.out.println("枚举中定义常量类型D===" + ConstantDemo3.TYPE_D);
    }
}

## 枚举常用方法

方法	说明
values()	枚举成员类型以数组方式返回
valueOf()	将字符串转换为枚举实例
ordinal()	获取枚举对象的位置索引值
compareTo()	比较两个枚举在定义时的前后顺序

示例：

   public enum ConstantDemo3 {
        /**
         * 枚举中定义常量
         */
        TYPE_N, TYPE_D;

        ConstantDemo3() {
        }

        static List<String> costants = new ArrayList<>();

        static {

            for (ConstantDemo3 value : ConstantDemo3.values()) {
                costants.add(value.name());
            }

        }

        public static List<String> getCostants() {
            return costants;
        }
    }
    public static void main(String[] args) {

        List<String> costants = ConstantDemo3.getCostants();

        costants.forEach(System.out::println);

        /**
         * TYPE_N
         * TYPE_D
         */


        ConstantDemo3 type_c = ConstantDemo3.valueOf("TYPE_D");

        ConstantDemo3[] values = ConstantDemo3.values();

        for (ConstantDemo3 value : values) {

            int index = type_c.compareTo(value);

            StringBuffer message = new StringBuffer();

            message.append(type_c).append("在").append(value);
            if (index < 0){
               message.append("前");
            } else if (index > 0) {
                message.append("后");
            } else if (index == 0) {
                message.append("同");
            }

            message.append(index).append("位，");

            message.append(value).append("在枚举中索引值").append(value.ordinal());
            System.out.println(message);
        }

        /**
         * TYPE_D在TYPE_N后1位，TYPE_N在枚举中索引值0
         * TYPE_D在TYPE_D同0位，TYPE_D在枚举中索引值1
         */
    }

枚举中的构造方法

在枚举类型中，可以添加构造方法，但是规定这个构造方法必须被private修饰符所修饰。

   public enum ConstantDemo3 {
        /**
         * 枚举中定义常量
         */
        SUCCESS(0, "success"),
        ERROR(-1, "parameter error");

        private int code;

        private String message;

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

        public int getCode() {
            return code;
        }

        public void setCode(int code) {
            this.code = code;
        }

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }

        static Map<Integer, String> sumMap = new HashMap<>();

        static {
            for (ConstantDemo3 value : ConstantDemo3.values()) {
                sumMap.put(value.code, value.message);
            }
        }

        public static Map<Integer, String> getSumMap() {
            return sumMap;
        }
    }

    public static void main(String[] args) {

        Map<Integer, String> sumMap = ConstantDemo3.getSumMap();

        sumMap.forEach((k, v) -> {
            System.out.println(k+"代码返回信息："+v);
        });

        /**
         * 0代码返回信息：success
         * -1代码返回信息：parameter error
         */
    }