Java 枚举（enum）剖析

左手的ㄟ右手 2021-12-10 14:23 474阅读 0赞

**目录**

Java 枚举（enum）概述

枚举常量

属性与方法

枚举参数

实现接口

抽象方法

--------------------

# Java 枚举（enum）概述 #

1、Java JDK 1.5 新增的 enum 关键词，可以定义枚举类，如 public enum WeekEnum \{ \}.

2、使用 enum 定义后的枚举类在编译后默认继承 java.lang.Enum 类，而不是普通的继承 Object 类。由于 Java 不支持多继承，所以枚举不能再显示的继承其他类，但是可以实现接口。

3、Enum 类默认实现了 Java.lang.Comparable 接口与 Serializable 接口

4、Enum 类重写了 toString 方法，返回声明中包含的此枚举常量的名称。

5、enum 声明后，该类会被编译器加上 final 声明（如同 String），故枚举无法被继承。

6、枚举类内部定义的枚举值就是该类的实例，且必须在第一行定义，当类初始化时，这些枚举值会被实例化，互相以逗号分隔。 如 "Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday"

7、每个枚举类都有一个 values 方法，该方法可以遍历枚举类的所有实例.

8、枚举规定好了指定的取值范围，所有的内容只能从指定的范围中取得。

9、枚举是一种类型，用于定义变量，以限制变量的赋值；通过 "枚举名.值" 取得枚举值，每个值都是一个 Enum 实例

10、枚举是一个特殊的类，可以定义自己的 field、方法、可以实现接口，也可以定义自己的构造器.

11、枚举类的构造方法默认用 private 修饰的，且不能出现 public 构造方法，因此无法 new 一个枚举对

13、实际编程中往往存在着这样的 "数据集"，它们的数值是稳定的、元素个数是有限的,例如星期一到星期日,春夏秋冬四季等等，很多时候大家选择使用常量。 JDK 1.5 开始有了枚举，其实可以把相关的常量放到一个枚举类型里，枚举提供了比常量更多的方法，使用起来更加方便。

# 枚举常量 #

1、定义枚举

/**
     * 星期，一周的枚举
     */
    public enum WeekEnum {
        /**
         * 最简单的枚举形式，使用逗号分隔，结尾分号此时可以省略
         * 每一个值都代表当前的枚举实例，通过 枚举名.值 获取
         */
        Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
    }

2、测试枚举：

import wmx.com.springboothello.enum_wmx.WeekEnum;
    public class Test {
        public static void main(String[] args) {
            //类似静态类，也是 枚举名.值 直接获取，每个值都是 Enum 实例
            WeekEnum sundayEnum = WeekEnum.Sunday;
            //因为 Enum 重写了 toString 方法，方法中返回 name 属性
            System.out.println("WeekEnum.Sunday=" + sundayEnum.toString());//输出 Sunday
            //返回此枚举常量的名称，与其枚举声明中声明的完全相同，看源码一目了然
            System.out.println("weekEnum.name()=" + sundayEnum.name());//输出 Sunday
            switch (sundayEnum) {
                case Monday:
                    System.out.println("星期1");
                    break;
                case Friday:
                    System.out.println("星期5");
                    break;
                case Sunday:
                    System.out.println("星期7");//会输出
            }
            //每个枚举类都有一个 values 方法，可以遍历枚举类的所有 Enum 实例.
            WeekEnum[] weekEnums = WeekEnum.values();
            for (WeekEnum weekEnum_loop : weekEnums) {
                //ordinal()：返回此枚举常数的序号（就是在枚举声明中的位置，从0开始）。
                System.out.print(weekEnum_loop.ordinal() + ":" + weekEnum_loop.name() + "  ");
            }
    
            /**
             * compareTo：看源码一目了然，就是根据序号 ordinal 对比同类型的枚举值是否相等
             * 自己的序号减去对比项的序号，如果为0则相等，否则就是正负数。注意只能对比相同枚举类型
             */
            WeekEnum mondayEnum = WeekEnum.Monday;
            int flag1 = sundayEnum.compareTo(mondayEnum);
            int flag2 = sundayEnum.compareTo(WeekEnum.Sunday);
            System.out.println("\n" + flag1 + "、" + flag2);//输出 6、0
        }
    }

# 属性与方法 #

1、枚举像普通的类一样可以添加属性和方法（包括静态或非静态的属性或方法）。注意枚举值要写在最前面，且以分号结尾，否则编译出错。

/**
     * 星期，一周的枚举
     */
    public enum WeekEnum {
        //枚举值写在最前面，有其他内容时，必须以分号结尾
        Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday;
        //枚举对象得通过上面得值来获取，其余得编码和普通的 类 区别不大
        private Integer id;
        public static String summary;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    }

2、测试代码：

import wmx.com.springboothello.enum_wmx.WeekEnum;
    public class Test {
        public static void main(String[] args) {
            //枚举名.值 获取实例。获取到实例后，其余得编码和普通的 类 区别不大
            WeekEnum sundayEnum = WeekEnum.Sunday;
    
            Integer id = sundayEnum.getId();//此时因为属性没有赋值，所以输出：null、null
            System.out.println(id + "、" + WeekEnum.summary);
    
            sundayEnum.setId(9527);//给id属性赋值
            id = sundayEnum.getId();//重新取值
            WeekEnum.summary = "梅山龙宫";//为静态属性赋值。如果枚举中有静态方法，则也是同理 枚举枚举名.静态方法名
            System.out.println(id + "、" + WeekEnum.summary);//输出：9527、梅山龙宫
        }
    }

# 枚举参数 #

1、枚举常量后面可以接括号定义枚举参数，这些参数会通过对应的构造器自动给属性赋值。"枚举参数 -> 对应的构造器 -> 属性" 完成赋值

/**
     * 星期，一周的枚举
     */
    public enum WeekEnum {
        //枚举值写在最前面，有其他内容时，必须以分号结尾。
        //因为枚举只能通过常量获取枚举实例，所以枚举参数必须与构造器中的参数对应
        Monday(1, "星期一"),//匹配两个参数的构造器创建实例
        Tuesday(2, "星期二"),
        Wednesday(3, "星期三"),
        Thursday(4, "星期四"),
        Friday(5, "星期五"),
        Saturday(6, "星期六"),
        Sunday(7, "星期天", "周末");//匹配三个参数的构造器创建实例
    
        //属性名称可以随便取，但是构造器中的参数类型必须与上面的枚举参数类型对应
        private Integer code;
        private String name;
        private String ext;
    
        //构造器默认是 private ，外部无法 new 枚举对象，只能通过上面的常量获取实例，必须与枚举参数对应
        WeekEnum(Integer code, String name) {
            this.code = code;
            this.name = name;
        }
    
        WeekEnum(Integer code, String name, String ext) {
            this.code = code;
            this.name = name;
            this.ext = ext;
        }
    
        //因为枚举常量的参数都是通过内部私有的构造器赋值的，无法通过外部赋值，所以没必要提供 setter方法
        //但是可以提供 getter 方法来获取枚举参数值
        public Integer getCode() {
            return code;
        }
    
        public String getName() {
            return name;
        }
    
        public String getExt() {
            return ext;
        }
    }

2、测试代码：

import wmx.com.springboothello.enum_wmx.WeekEnum;
    public class Test {
        public static void main(String[] args) {
            //枚举名.值 获取实例，这些值之所以叫枚举常量，因为它的值就如同常量一样一开始就顶死了的，无法修改
            WeekEnum sundayEnum = WeekEnum.Sunday;
            WeekEnum mondayEnum = WeekEnum.Monday;
            //上面的实例包含了自己枚举参数，所以可以通过 getter 方法获取
            System.out.println(sundayEnum.getCode() + "->" + sundayEnum.getName() + "->" + sundayEnum.getExt());
            System.out.println(mondayEnum.getCode() + "->" + mondayEnum.getName() + "->" + mondayEnum.getExt());
            //输出：7->星期天->周末
            //输出：1->星期一->null。因为星期一没有提供 ext 参数，所以为 null
        }
    }

2、总结：

> 枚举的构造器私有，每一个枚举值都是一个枚举实例，编译后自动产生。枚举值的参数与构造器的参数相对应，即枚举值后面没跟参数时，构造器也是无参构造，  
> 枚举值后面跟参数时，必须要有参数个数且类型相同的构造器与之对应，以及设置相应的成员变量。
> 
> 编译构建实例的顺序是：枚举值后面的实参值->找到对应的构造方法->注入给相应的成员变量。因为构造器可以重载，所以枚举值后面的参数可以不同，包括类型与个数。  
> 每个枚举值既可以调用自己独有的属性，即后面的参数值，也可以调用公共的属性，即可调用自己下面独有的方法，也可调用公共的方法。
> 
> 当枚举值/枚举常量没有带参数时，则没必要要构造器，反之如果枚举值有参数，则必须有构造器与之对应

# 实现接口 #

1、先准备一个接口：

import java.util.Map;
    public interface WeekEnumInterface {
        Integer getCode();
        String getName();
        Map<String, Object> getDataMap();
    }

2、定义枚举并实现接口

import java.util.HashMap;
    import java.util.Map;
    /**
     * 星期，一周的枚举
     * 枚举 enum 默认已经继承了 Enum 类，所以无法再继承，但是可以实现接口
     */
    public enum WeekEnum implements WeekEnumInterface {
        //枚举值写在最前面，有其他内容时，必须以分号结尾。
        //因为枚举只能通过常量获取枚举实例，所以枚举参数必须与构造器中的参数对应
        Monday(1, "星期一"),//匹配两个参数的构造器创建实例
        Tuesday(2, "星期二"),
        Wednesday(3, "星期三"),
        Thursday(4, "星期四"),
        Friday(5, "星期五"),
        Saturday(6, "星期六"),
        Sunday(7, "星期天");
    
        //属性名称可以随便取，但是构造器中的参数类型必须与上面的枚举参数类型对应
        private Integer code;
        private String name;
    
        //构造器默认是 private ，外部无法 new 枚举对象，只能通过上面的常量获取实例，必须与枚举参数对应
        WeekEnum(Integer code, String name) {
            this.code = code;
            this.name = name;
        }
    
        @Override
        public Integer getCode() {
            return code;
        }
    
        @Override
        public String getName() {
            return name;
        }
    
        //将整个枚举参数转为 Map 结构
        @Override
        public Map<String, Object> getDataMap() {
            Map<String, Object> dataMap = new HashMap<>(WeekEnum.values().length);
            for (WeekEnum weekEnum : WeekEnum.values()) {
                dataMap.put(weekEnum.code + "", weekEnum.name);
            }
            return dataMap;
        }
    }

3、测试代码：

import wmx.com.springboothello.enum_wmx.WeekEnum;
    import java.util.Map;
    public class Test {
        public static void main(String[] args) {
            //枚举名.值 获取实例，这些值之所以叫枚举常量，因为它的值就如同常量一样一开始就顶死了的，无法修改
            WeekEnum sundayEnum = WeekEnum.Sunday;
            System.out.println(sundayEnum.getCode() + " - " + sundayEnum.getName());
            //
            Map<String, Object> dataMap = sundayEnum.getDataMap();
            for (Map.Entry<String, Object> entry : dataMap.entrySet()) {
                System.out.println(entry.getKey() + " = " + entry.getValue());
            }
        }
    }

# 抽象方法 #

1、枚举中可以有抽象方法，且由枚举值/枚举常量提供方法实现。枚举类如下：

/**
     * 星期，一周的枚举
     * 枚举 enum 默认已经继承了 Enum 类，所以无法再继承，但是可以实现接口
     */
    public enum WeekEnum {
        //枚举值写在最前面，有其他内容时，必须以分号结尾。
        //因为枚举只能通过常量获取枚举实例，所以枚举参数必须与构造器中的参数对应
        Monday(1, "星期一") {
            @Override
            public String toSplitString() {
                return Monday.code + "," + Monday.name;
            }
        },//匹配两个参数的构造器创建实例
        Tuesday(2, "星期二") {
            @Override
            public String toSplitString() {
                return Tuesday.getCode() + "," + Tuesday.getName();
            }
        };
    
        //属性名称可以随便取，但是构造器中的参数类型必须与上面的枚举参数类型对应
        private Integer code;
        private String name;
    
        //构造器默认是 private ，外部无法 new 枚举对象，只能通过上面的常量获取实例，必须与枚举参数对应
        WeekEnum(Integer code, String name) {
            this.code = code;
            this.name = name;
        }
    
        public Integer getCode() {
            return code;
        }
    
        public String getName() {
            return name;
        }
    
        //方法要是 public 修饰外部才能调用
        public abstract String toSplitString();
    }

2、测试代码：

import wmx.com.springboothello.enum_wmx.WeekEnum;
    public class Test {
        public static void main(String[] args) {
            //枚举名.值 获取实例，这些值之所以叫枚举常量，因为它的值就如同常量一样一开始就顶死了的，无法修改
            WeekEnum mondayEnum = WeekEnum.Monday;
            WeekEnum tuesdayEnum = WeekEnum.Tuesday;
            System.out.println(mondayEnum.getCode() + " - " + mondayEnum.getName());//输出：1 - 星期一
            System.out.println(tuesdayEnum.getCode() + " - " + tuesdayEnum.getName());//输出：2 - 星期二
            System.out.println(mondayEnum.toSplitString());//输出：1,星期一
            System.out.println(tuesdayEnum.toSplitString());//输出：2,星期二
        }
    }