一、什么是枚举类

1、在某些情况下，一个类的对象时有限且固定的，如季节类，它只有春夏秋冬4个对象这种实例数目有限且固定的类，在 Java 中可以定义为枚举类。
2、枚举类是一种特殊的类，它和普通的类一样，有自己的成员变量、成员方法、构造器 (只能使用 private 访问修饰符，所以无法从外部调用构造器，构造器只在构造枚举值时被调用)；

二、特点

1、底层是个class；
2、枚举类隐式的继承了java.lang.Enum的父类；
3、可以实现其他的接口；
4、普通的枚举类通常是final的；
5、枚举类的对象必须在枚举类的第一行显示的定义出来；
6、枚举类的对象都是public static final的，被隐式修改,这也是是为什么枚举类的对象我们可以直接使用类名调，并且要定义为大写的原因；
7、枚举类的构造都是private；
8、枚举类型可以像类(class)类型一样，定义为一个单独的文件，当然也可以定义在其他类内部；
9、枚举类的所有对象都重写实现了抽象方法，那么这个枚举类成为了一个抽象的枚举类。

三、枚举类的定义

1、定义一个简单枚举类

// 定义一个星期的枚举类
public enum WeekEnum {
    // 在第一行显式地列出7个枚举实例(枚举值)，系统会自动添加 public static final 修饰
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
}

2、带成员变量、成员方法、构造器的枚举类

public enum WeekEnum {
    
    // 因为已经定义了带参数的构造器，所以在列出枚举值（对象）时必须传入对应的参数
    SUNDAY("星期日"), MONDAY("星期一"), TUESDAY("星期二"), WEDNESDAY("星期三"), 
    THURSDAY("星期四"), FRIDAY("星期五"), SATURDAY("星期六");

    // 定义一个 private 修饰的实例变量
    private String date;

    // 定义一个带参数的构造器，枚举类的构造器只能使用 private 修饰
    private WeekEnum(String date) {
        this.date = date;
    }

    // 定义 get set 方法
    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }
    
}

3、枚举对象的方法

（1）、不重写toString的情况下

/** * 枚举对象的方法 */
    @Test
    public void testMethod() {
        WeekEnum monday = WeekEnum.MONDay;
        // name()
        String name = WeekEnum.MONDay.name();
        // ordinal,返回枚举值在枚举类中的索引值(从0开始)，即枚举值在枚举声明中的顺序
        int ordinal = WeekEnum.MONDay.ordinal();
        // toString
        String string = WeekEnum.MONDay.toString();
        System.out.println(monday);
        System.out.println(name);
        System.out.println(ordinal);
        System.out.println(string);
    }

打印结果：

MONDay
MONDay
0
MONDay

Process finished with exit code 0

（2）、重写toString的情况下：

// 重写父类的方法,也只能重写这个方法，一般不重写
    @Override
    public String toString() {
        return "WeekEnum{" +
                "index=" + index +
                ", date='" + date + '\'' +
                '}';
    }
}

打印结果：

WeekEnum{index=1, date='星期一'}
MONDay
0
WeekEnum{index=1, date='星期一'}

Process finished with exit code 0

我们可以看到：
1、通过.name()方法我们可以获取枚举对象的名称，通过.ordinal方法可以获取枚举对象的索引；
2、可以看到，重写 toString 方法前后所返回的枚举值不同！不重写toString()方法，我们获取枚举对象相当于获取到的是.name()或.toString()后得到的字符串，重写后得到的就是toString后的对象的字符串。
3、枚举类型对象之间的值比较，是可以使用==来直接来比较值是否相等的，不是equals。

System.out.println(WeekEnum.MONDay == WeekEnum.MONDay);
System.out.println(WeekEnum.MONDay != WeekEnum.SATURDAY);

4、枚举类的静态方法

（1）、values()

public void testStatic() {
        // values方法得到一个枚举值的数组，枚举值与toString对应
        WeekEnum[] values = WeekEnum.values();
        String string = Arrays.toString(values);
        System.out.println(string);
    }

打印结果：

[WeekEnum{index=1, date='星期一'}, WeekEnum{index=2, date='星期二'}, WeekEnum{index=3, date='星期三'}, WeekEnum{index=4, date='星期四'}, WeekEnum{index=5, date='星期五'}, WeekEnum{index=6, date='星期六'}, WeekEnum{index=0, date='null'}]

（2）、valueOf()

// valueOf(String name),返回带指定名称的指定枚举类型的枚举常量，名称必须与在此类型中声明枚举常量所用的标识符完全匹配
        WeekEnum monDay = WeekEnum.valueOf("MONDay");
        System.out.println(monDay);

打印结果：

WeekEnum{index=1, date='星期一'}

四、枚举类的使用

1、常量

在JDK1.5 之前，我们定义常量都是这样的：

public static fianl String Male = "1"

现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，通过枚举类属性的get方法来获取常量值：

public enum SexEnum {
    // 枚举对象
    MALE("1"),
    FAMALE("0");

    // 属性
    private String value;

    // get
    public String getValue() {
        return value;
    }
    // set
    public void setValue(String value) {
        this.value = value;
    }

    // 构造方法
    SexEnum(String value) {
        this.value = value;
    }
}

// 通过枚举对象的get方法获取常量值
String value = SexEnum.FAMALE.getValue();  // 结果为”1“

2、switch

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。

public enum ColorEnum {
    // 定义三个枚举类型的简单对象，无参构造
    RED,
    GREEN,
    BLUE
}

/** * 枚举配合switch使用 * @param colorEnum */
    public void toSwitch(ColorEnum colorEnum) {
        switch (colorEnum) {
            case RED:
                System.out.println("这是红色");
                break;
            case GREEN:
                System.out.println("今这是绿色");
                break;
            case BLUE:
                System.out.println("这是蓝色");
                break;
            default:
                System.out.println("无色");
                break;
        }
    }

@Test
    public void testSwitch() {
        toSwitch(ColorEnum.RED);
    }

五、使用枚举类实现接口

与普通类一样，枚举类也可以实现一个或多个接口。枚举类实现接口时，同样要实现
该接口的所有方法。

public interface GenderDescription {
    
    public void info();

}

上面定义了一个接口，该接口有一个 info() 方法，凡是实现该接口的类都需要实现该方法。

public enum Gender implements GenderDescription {
    
    MALE,FEMALE;

    @Override
    public void info() {
        System.out.println("这是一个用于定义性别的枚举类");
    }

}

public class Test02 {

    public static void main(String[] args) {
        Gender.MALE.info();
        Gender.FEMALE.info();
    }
    
}

运行结果：

六、包含抽象方法的枚举类

定义一个 Operation 枚举类，有4个枚举值PLUS、MINUS、TIMES、DIVIDE，分别代表加、减、乘、除，该枚举类有一个 calculate() 方法，用于完成计算。

public enum Operation {

    // 用于执行加法运算
    PLUS { // 花括号部分其实是一个匿名内部子类

        @Override
        public double calculate(double x, double y) {
            return x + y;
        }

    },

    // 用于执行减法运算
    MINUS { // 花括号部分其实是一个匿名内部子类

        @Override
        public double calculate(double x, double y) {
            // TODO Auto-generated method stub
            return x - y;
        }

    },

    // 用于执行乘法运算
    TIMES { // 花括号部分其实是一个匿名内部子类

        @Override
        public double calculate(double x, double y) {
            return x * y;
        }

    },

    // 用于执行除法运算
    DIVIDE { // 花括号部分其实是一个匿名内部子类

        @Override
        public double calculate(double x, double y) {
            return x / y;
        }

    };

    //为该枚举类定义一个抽象方法，枚举类中所有的枚举值都必须实现这个方法
    public abstract double calculate(double x, double y);

}

枚举类的所有对象都重写实现了抽象方法，那么这个枚举类成为了一个抽象的枚举类。

public class Test03 {

    public static void main(String[] args) {
        System.out.println("6 + 2 = " + Operation.PLUS.calculate(6, 3));
        System.out.println("6 - 2 = " + Operation.MINUS.calculate(6, 2));
        System.out.println("6 * 2 = " + Operation.TIMES.calculate(6, 2));
        System.out.println("6 / 2 = " + Operation.DIVIDE.calculate(6, 2));
    }

}

运行结果：