【Java知识点详解 5】Java枚举详解

朴灿烈づ我的快乐病毒、 2021-08-30 23:59 407阅读 0赞

# 一、基本概念 #

枚举是Java1.5引入的新特性，通过关键字enum来定义枚举类。枚举类是一种特殊类，它和普通类一样可以使用构造器、定义成员变量和方法，也能实现一个或多个接口,但枚举类不能继承其他类。

# 二、枚举的优缺点 #

## 1、优点 ##

Effctive Java中之所以推荐用枚举代替所有常量Code,原因如下:

（1）类型检查，有效性检查

（2）枚举作为一个类,可以有自己的属性(通常应该是常量，我没遇到过不是的情况)以及自己的方法(否则只能用switch来写，实际违反原则)

（3）和常量相比，无需查看文档和源码就能直接知道所有可能返回值，方便编码。

然而这里的问题就出在第一点上,实际上分布式环境下（1）并不是必然的。如果业务处理中允许某个接口返回值有未定义内容，那么在反序列化中就不该对此抛出异常,不必死守（1）。同时,从第（2）点和第（3）点来看，这样限制枚举的使用范围造成的影响是极大的。将有自己属性,自己方法实现的枚举改写为code和其他方法的配合，需要的代码量上升不少,而且代码腐烂度极大增加。

## 2、缺点 ##

（1）由于Java中支持单继承，因此枚举类型不能再继承其他类；

（2）使用枚举作为返回值可能造成的问题其实大家都知道就是客户端和服务端版本不一致的话,会造成反序列化异常，于是《阿里巴巴JAVA开发手册》对于这个问题的处理办法就采取了尽量避免异常出现,所以禁止定义枚举为返回值。

# 三、解决ifelse #

对于业务开发来说，业务逻辑的复杂是必然的，随着业务发展，需求只会越来越复杂，为了考虑到各种各样的情况，代码中不可避免的会出现很多if-else。

一旦代码中if-else过多，就会大大的影响其可读性和可维护性，而且代码显得很low。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70][]

枚举可以解决这个问题；

关于枚举与switch是个比较简单的话题，使用switch进行条件判断时，条件参数一般只能是整型，字符型。而枚举型确实也被switch所支持，在java 1.7后switch也对字符串进行了支持。这里我们简单看一下switch与枚举类型的使用

static void testSwitch(Week week){
        switch (week){
            case MONDAY:
                System.out.println(week.getMeaning());
                break;
            case TUESDAY:
                System.out.println(week.getMeaning());
                break;
            case WEDNESDAY:
                System.out.println(week.getMeaning());
                break;
            case THURSDAY:
                System.out.println(week.getMeaning());
                break;
            case FRIDAY:
                System.out.println(week.getMeaning());
                break;
            case SATURDAY:
                System.out.println(week.getMeaning());
                break;
            case SUNDAY:
                System.out.println(week.getMeaning());
                break;
            default:
                System.out.println("您输入有误");
                break;
        }
    }

# 四、枚举的常用方法 #

# ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1][] #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2][]

##  1、枚举类 ##

enum Weekday {
        SUNDAY(0),
        MONDAY(1),
        TUESDAY(2),
        WEDNESDAY(3),
        THURSDAY(4),
        FRIDAY(5),
        SATURDAY(6);
        
        private int value;
        
        Weekday(int value) {
            this.value = value;
        }
    }

## 2、枚举类变量中添加属性 ##

enum Week{
        SUNDAY(0,"星期日"),
        MONDAY(1,"星期一"),
        TUESDAY(2,"星期二"),
        WEDNESDAY(3,"星期三"),
        THURSDAY(4,"星期四"),
        FRIDAY(5,"星期五"),
        SATURDAY(6,"星期六");
    
        private int id;
        private String meaning;
    
        Week(int id,String meaning) {
            this.id = id;
            this.meaning = meaning;
        }
    }

## 3、测试类  ##

public static void main(String[] args) {
            //1、ordinal(),枚举顺序值
            System.out.println("枚举顺序值,"+Weekday.MONDAY.ordinal());//1
    
            /*
             * 2、valueOf()
             * public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name)
             * enumType -- 这是枚举类型，返回一个常量的类的对象。
             * name -- 这是常量，要返回的名称。
             * return:此方法返回具有指定名称的枚举类型的枚举常量。
             * 如果你传了一个不存在的字符串，那么会抛出异常。
             * */
            Week week = Enum.valueOf(Week.class,Week.MONDAY.name().toString());
            Week week1 = Week.valueOf(Week.class,Week.MONDAY.name());
            System.out.println("Enum.valueOf,"+week);//MONDAY
            System.out.println("Week.valueOf,"+week1);//MONDAY
    
            //3、values()
            System.out.println("Week.values(),"+Weekday.values());//返回一个Weekday数组,[Ljavase.enumeration.Weekday;@2a84aee7
    
            //4、通过compareTo方法比较,实际上其内部是通过ordinal()值比较的
            System.out.println("Weekday.MONDAY.compareTo(Weekday.TUESDAY),"+Weekday.MONDAY.compareTo(Weekday.TUESDAY));//false
    
            //5、获取该枚举对象的Class对象引用,当然也可以通过getClass方法
            Class<?> declaringClass = Weekday.MONDAY.getDeclaringClass();
            System.out.println("获取该枚举对象的Class对象引用,"+declaringClass);//javase.enumeration.Weekday
    
            //6、通过getEnumConstants()获取该枚举类型的所有元素，如果Class对象不是枚举类型，则返回null。
            Object[] enumConstants = declaringClass.getEnumConstants();
            //枚举类个数,Weekday.values().length)
            for (int i = 0; i < Weekday.values().length; i++) {
                System.out.println("getEnumConstants,"+enumConstants[i]);//SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY
            }
    
            //7、判断是否是枚举类型
            System.out.println("declaringClass.isEnum(),"+declaringClass.isEnum());//true
    
            //8、获取枚举变量的属性
            System.out.println("编号,"+Week.MONDAY.getId()+",含义,"+Week.MONDAY.getMeaning());
        }

## 4、向上转型 ##

//9、向上转型Enum
    Enum e = Weekday.FRIDAY;

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 3][]

这个东西意义何在，有待研究。

## 5、部分方法源码介绍 ##

### （1）valueof ###

public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name) {
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    }

### （2）compareTo  ###

public final int compareTo(E o) {
        Enum<?> other = (Enum<?>)o;
        Enum<E> self = this;
        if (self.getClass() != other.getClass() && self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }

# 五、枚举类中定义抽象方法 #

## 1、定义抽象方法 ##

package javase.enumeration;
    
    public enum Season{
        SPRING("1"){
            @Override
            public Season getNextSeason() {
                return SUMMER;
            }
        },
        SUMMER("4"){
            @Override
            public Season getNextSeason() {
                return AUTUMN;
            }
        },
        AUTUMN("7"){
            @Override
            public Season getNextSeason() {
                return WINTER;
            }
        },
        WINTER("10"){
            @Override
            public Season getNextSeason() {
                return SPRING;
            }
        };
    
        private String monthStart;
        private Season(String monthStart){
            this.monthStart = monthStart;
        }
    
        public abstract Season getNextSeason();
    }

## 2、测试类 ##

class Test{
        public static void main(String[] args) {
            System.out.println("SPRING下一个季节是："+Season.SPRING.getNextSeason());
        }
    }

## 3、控制台输出 ##

![20200616161522223.png][]

# 六、实现接口  #

## 1、接口 ##

package javase.enumeration;
    
    public interface Study {
        void StudyJava();
        void StudyDataStrucure();
        void StudyDesignMode();
        void StudySpring();
    }

## 2、实现接口  ##

enum Week implements Study{
        SUNDAY(0,"星期日"),
        MONDAY(1,"星期一"),
        TUESDAY(2,"星期二"),
        WEDNESDAY(3,"星期三"),
        THURSDAY(4,"星期四"),
        FRIDAY(5,"星期五"),
        SATURDAY(6,"星期六");
    
        private int id;
        private String meaning;
    
        Week(int id,String meaning) {
            this.id = id;
            this.meaning = meaning;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getMeaning() {
            return meaning;
        }
    
        public void setMeaning(String meaning) {
            this.meaning = meaning;
        }
    
        @Override
        public String toString() {
            return "Week{" +
                    "id=" + id +
                    ", meaning='" + meaning + '\'' +
                    '}';
        }
    
        @Override
        public void StudyJava() {
            System.out.println(this+"学习java");
        }
    
        @Override
        public void StudyDataStrucure() {
            System.out.println(this.meaning+"学习数据结构");
        }
    
        @Override
        public void StudyDesignMode() {
            System.out.println(this.meaning+"学习设计模式");
        }
    
        @Override
        public void StudySpring() {
            System.out.println(this.meaning+"学习Spring框架");
        }
    }

## 3、测试类 ##

//10、实现接口并调用接口中方法
    MONDAY.StudyDataStrucure();

## 4、控制台输出 ##

![20200616161814644.png][]

# 七、枚举实现单例 #

枚举单例（Enum Singleton）在Effective Java一书中提到，因为其功能完善，使用简洁，无偿的提供了序列化机制，在面对复杂的序列化或者反射攻击时依然可以绝对防止多次实例化等优点，被作者所推崇。

public enum  DataSourceEnum {
        DATASOURCE;
        private DBConnection connection = null;
        private DataSourceEnum(){
            connection = new DBConnection();
        }
        public DBConnection getConnection(){
            return connection;
        }
    }

# 八、EnumMap #

##  1、代码实例分析EnumMap和HashMap ##

以1月到6月学习不同的Java项目为例。

/*
    * 以1月到6月学习不同的Java项目为例
    * */
    public class EnumMapDemo {
        public static void main(String[] args) {
            List<StudyJava> list = new ArrayList<>();
            list.add(new StudyJava("January",ProjectEnum.SSH));
            list.add(new StudyJava("February",ProjectEnum.SSM));
            list.add(new StudyJava("March",ProjectEnum.SSM));
            list.add(new StudyJava("April",ProjectEnum.SPRINGBOOT));
            list.add(new StudyJava("May",ProjectEnum.SPRINGBOOT));
            list.add(new StudyJava("June",ProjectEnum.SPRINGCLOUD));
            //1、使用hashmap
            Map<ProjectEnum,Integer> hashMap = new HashMap<>();
            for (StudyJava studyJava:list){
                ProjectEnum project = studyJava.getProjectEnum();
                Integer count = hashMap.get(project);
                if(count != null){
                    hashMap.put(project,count + 1);
                }else{
                    hashMap.put(project,1);
                }
            }
            System.out.println(hashMap.toString());
    
            //2、使用EnumMap
            Map<ProjectEnum,Integer> enumMap = new EnumMap(ProjectEnum.class);
            for (StudyJava studyJava:list){
                ProjectEnum project = studyJava.getProjectEnum();
                Integer count = enumMap.get(project);
                if(count!=null){
                    enumMap.put(project,count+1);
                }else {
                    enumMap.put(project,1);
                }
            }
            System.out.println(enumMap.toString());
        }
    }
    
    enum ProjectEnum {
        SSM,
        SSH,
        SPRINGBOOT,
        SPRINGCLOUD;
    }
    
    class StudyJava{
        private String month;
        private ProjectEnum projectEnum;
    
        public StudyJava(String month, ProjectEnum projectEnum) {
            this.month = month;
            this.projectEnum = projectEnum;
        }
    
        public String getMonth() {
            return month;
        }
    
        public void setMonth(String month) {
            this.month = month;
        }
    
        public ProjectEnum getProjectEnum() {
            return projectEnum;
        }
    
        public void setProjectEnum(ProjectEnum projectEnum) {
            this.projectEnum = projectEnum;
        }
    }

## 2、控制台输出 ##

![20200617102637841.png][]

## 3、结果分析 ##

### HashMap对比EnumMap ###

HashMap和EnumMap的输出结果一致，证明枚举类型都可以使用，但是EnumMap作为枚举的专属的集合，我们没有理由再去使用HashMap，毕竟EnumMap要求其Key必须为Enum类型。

由于枚举类型实例的数量相对固定并且有限，所以EnumMap使用数组来存放与枚举类型对应的值，毕竟数组是一段连续的内存空间，根据程序局部性原理，效率会相当高。

*  EnumMap需要传递一个类型信息，即Class对象，通过这个参数EnumMap就可以根据类型信息初始化器内部数据结构，也可以初始化时传入一个Map集合。
 *  key值不能为null。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 4][]

## 4、简单的源码分析 ##

### （1）EnumMap继承了AbstractMap类，因此EnumMap具备一般map的使用方法。 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 5][]

### （2）由于key值基本固定，底层数组实现，效率更高 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 6][]

### （3）获取key数组方法 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 7][]

### （4）put() ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 8][]

![20200617104518556.png][]

### （5）get() ###

![20200617104744583.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 9][]

### （6）remove() ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 10][]

### （7）containsKey() ###

![20200617105824480.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 11][]

以上就是EnumMap的源码分析，即内部有两个数组，长度相同，一个是以枚举为key的数组，一个是对应的值数组，key不允许null，value可以为null，键都有一个对应的索引，根据索引直接访问和操作其键数组和值数组，由于操作时都是数组，所以效率比HashMap高。

![20200617115054221.jpg][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70]: /images/20210813/076c7f8b64b941d0b352cb114eb44100.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1]: /images/20210813/bbb7d7bf28f04ce28541145bac573a06.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2]: /images/20210813/c1824cab2fc7442e8c5e238d3f3cb268.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 3]: /images/20210813/3430aa9c93ad4a16807ec89ee35dfac9.png
[20200616161522223.png]: /images/20210813/9b2677ee645f443bb0a5269dd8933746.png
[20200616161814644.png]: /images/20210813/5cc55319954345cb90e04bae7ba4158e.png
[20200617102637841.png]: /images/20210813/ff4c549ee2984de6bb2bd3f1462efd23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 4]: /images/20210813/f78a8753dd454255aaf9ca4e01968f4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 5]: /images/20210813/3d7594f286684ec88055c89551ec9831.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 6]: /images/20210813/0f5c55dae2444733a63089321cc8c734.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 7]: /images/20210813/eb48c2b875ee43e282ffd92a683cab5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 8]: /images/20210813/c8c50eb6244d42b1a0e762ef3e97d60e.png
[20200617104518556.png]: /images/20210813/cbbfa9877a7e441790cf90abdcd3bb96.png
[20200617104744583.png]: /images/20210813/507e12b54c88430696de9744ea76134b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 9]: /images/20210813/c870c52227af4f2182d4a939bb2f3627.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 10]: /images/20210813/9420312d407f482e97107236311aa6ad.png
[20200617105824480.png]: /images/20210813/d0c319d205ef44a2a5bd73b21dfce376.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 11]: /images/20210813/3bd4b19db91b4c80b84d2c46e2d6e2d6.png
[20200617115054221.jpg]: /images/20210813/082024c15d57447faf2976cb7cb26ec2.png