深入理解Java枚举类型(enum)

一、基本概念

枚举是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。

枚举可以解决这个问题；

关于枚举与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;
    }
}

​

四、枚举的常用方法

返回类型	方法名称	方法说明
int	compareTo(E o)	比较此枚举与指定对象的顺序
boolean	equals(Object other)	当指定对象等于此枚举常量时，返回 true。
Class<?>	getDeclaringClass()	返回与此枚举常量的枚举类型相对应的 Class 对象
String	name()	返回此枚举常量的名称，在其枚举声明中对其进行声明
int	ordinal()	返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）
String	toString()	返回枚举常量的名称，它包含在声明中
static<T extends Enum<T>> T	static valueOf(Class<T> enumType, String name)	返回带指定名称的指定枚举类型的枚举常量。

 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;

 

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

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、控制台输出

六、实现接口 

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、控制台输出

七、枚举实现单例

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

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