你举不举！举不举！就问你举不举？（枚举类型）

在开发过程中，经常遇到一个一个类的实例对象是有限而且是固定的情况。例如季节类，只有春夏秋冬四个实例对象，；再比如月分类只有12个实例对象。这种类的实例对象有限而且是固定的，在Java中被称为枚举类。
枚举类是一种特殊的类型，与普通类有着一定的区别：
✳枚举类可以实现一个或者多个接口，使用enum定义的枚举类默认继承的是java.lang.Enum类，而不是继承Object类，因此枚举类不能显式的继承其他父类
✳使用enum定义非抽象的枚举类型时默认会使用final进行修饰，因此枚举类型不能派生出子类。
✳枚举类型的构造方法只能使用private访问修饰符，如果省略，则默认是使用private修饰；如果强制指定访问修饰符，也只能默认是private。
✳枚举类的所有的实例必须在枚举类的类型第一行显式的列出，否则该枚举类型将永远不能产生实例。列出的枚举实例默认使用的是public static final进行修饰。
定义枚举类
使用enum关键字定义一个枚举类型，下面代码定义一个枚举实例：

public enum SeasonEnum{
      SPRING,SUNMMER,FALL,WINTER;
}

枚举类型一旦被定义，就可以直接使用该类型的枚举类型，枚举实例的声明和使用方法类似于基本类型，但不能使用new关键字实例化一个枚举
所有的枚举类型都会包括两个预定义的方法：values()和valuesOf()

方法	功能描述
public static enumtype []values()	返回一个枚举类型的数组，包含该枚举类型的所有实例值
public static enumtype valuesOf(String str)	返回指定名称的枚举类型

public class SeasonEnumDemo {
    public enum SeasonEnum{
        SPRING,SUMMER,FALL,WINTER;
    }
    public static void main(String[] args) {
        System.out.println("SeasonEnum枚举类的所有实例值：");
        for (SeasonEnum s : SeasonEnum.values()) {
            System.out.println(s);
        }
        System.out.println("-------------------------------");
        SeasonEnum seasonEnum = SeasonEnum.WINTER;
        switch (seasonEnum){
            case SPRING:
                System.out.println("春暖花开,踏青时日");
                break;
            case SUMMER:
                System.out.println("夏日炎炎，有你超甜");
                break;
            case FALL:
                System.out.println("秋高气爽，进补及时");
                break;
            case WINTER:
                System.out.println("冬日雪飘，围炉赏雪");
                break;
        }
    }
}

上述代码需要注意：
✳调用values()方法可以返回SeasonEnum枚举类型的所有实例值；
✳定义一个枚举类型的对象时不能使用new关键字，而是使用枚举类型的实例值直接赋值；
✳在switch语句中直接使用枚举类型作为表达式进行判断，而case表达式中的值直接使用枚举类型实例值的名字，前面不能使用枚举类型作为限制条件
包含属性和方法的枚举类
枚举类也是一种类，具有与其他类几乎相同的特性，因此可以定义枚举的属性、方法以及构造方法。但是，枚举类的构造方法只能是在构造枚举实例值的时候被调用。每一个枚举实例值都是一个枚举类的对象，因此创建每个枚举实例时都需要调用改构造方法。例如下面：

package Enumeration;

public class SeasonEnumDemo2 {
    public enum SeasonEnum2{
        SPRING("春"),SUMMER("夏"),FALL("秋"),WINTER("冬");
        private String name;
        SeasonEnum2(String name){
            this.name = name;
        }
        public String toString(){
            return this.name;
        }
    }
    public static void main(String[] args) {
        System.out.println("SeasonEnum枚举类的所有实例值：");
        for (SeasonEnum2 s : SeasonEnum2.values()) {
            System.out.println(s);
        }
        System.out.println("-----------------------");
        SeasonEnum2 se = SeasonEnum2.valueOf("SUMMER");
        System.out.println(se);
        judge(se);
        System.out.println("-----------------------");
        SeasonEnum2 season = SeasonEnum2.WINTER;//定义一个枚举类对象并直接赋值
        System.out.println(season);//输出season
        judge(season);//调用judge方法
    }
    //判断季节并输出
    private static void judge(SeasonEnum2 season) {
        //使用switch语句判断枚举值
        switch (season){
            case SPRING:
                System.out.println("春暖花开,踏青时日");
                break;
            case SUMMER:
                System.out.println("夏日炎炎，有你超甜");
                break;
            case FALL:
                System.out.println("秋高气爽，进补及时");
                break;
            case WINTER:
                System.out.println("冬日雪飘，围炉赏雪");
                break;
        }
    }
}

这个运行结果和之前的就有所不同，此处输出的是“春夏秋冬”，而不是SPRING,SUMMER,FALL,WINTER。这主要是因为在定义枚举类时重写了toString()方法，该方法返回值为name属性值，当调用System.out.println()方法输出时，系统自动调用的是toString()方法。
Enum类
所有的枚举类都继承自java.lang.Enum，该类定义了枚举类公用的方法。java.lang.Enum类实现了java.Serializable和java.lang.Comparable两个接口。Enum类常用方法如下：

方法	功能描述
final int ordinal	返回枚举实例值在枚举类中的序号，该序号与声明的顺序有关，计数从0开始
final int compareTo(enumtype e)	Enum实现了java.lang.Conparable接口，因此可以用于比较
boolean equals(Object other)	比较两个枚举引用的对象是否相等
public String toString()	返回枚举实例的名称，一般情况下无须重写该方法，但是当存在更加友好的字符串形式时可以重写此方法
public static <T extendsEnum>T valueOf(class enumType,String name)	返回指定枚举类型和指定名称的枚举实例值

public class EnumMethodDemo {

	public static void main(String[] args) {
		System.out.println("SeasonEnum枚举类的所有实例值以及顺序号：");
		// 输出SeasonEnum类的实例值以及顺序号
		for (SeasonEnum s : SeasonEnum.values()) {
			System.out.println(s + "--" + s.ordinal());
		}
		System.out.println("---------------------");
		// 声明4个SeasonEnum对象
		SeasonEnum s1, s2, s3, s4;
		// 赋值
		s1 = SeasonEnum.SPRING;
		s2 = SeasonEnum.SUMMER;
		s3 = SeasonEnum.FALL;
		// 调用Enum类的静态方法获取指定枚类型、指定值的枚举实例
		s4 = Enum.valueOf(SeasonEnum.class, "FALL");
		// 等价于
		// s4 = SeasonEnum.valueOf("FALL");

		// 使用compareTo()进行比较
		if (s1.compareTo(s2) < 0) {
			System.out.println(s1 + "在" + s2 + "之前");
		}
		// 使用equals()判断
		if (s3.equals(s4)) {
			System.out.println(s3 + "等于" + s4);
		}
		// 使用==判断
		if (s3 == s4) {
			System.out.println(s3 + "==" + s4);
		}
		System.out.println("---------------------");

		System.out.println("SeasonEnum2枚举类的所有实例值以及顺序号：");
		// 输出SeasonEnum类的实例值以及顺序号
		for (SeasonEnum2 s : SeasonEnum2.values()) {
			System.out.println(s + "--" + s.ordinal());
		}
		System.out.println("---------------------");
		// 声明4个SeasonEnum对象
		SeasonEnum2 se1, se2, se3, se4;
		// 赋值
		se1 = SeasonEnum2.SPRING;
		se2 = SeasonEnum2.SUMMER;
		se3 = SeasonEnum2.FALL;
		// 调用Enum类的静态方法获取指定枚类型、指定值的枚举实例
		se4 = Enum.valueOf(SeasonEnum2.class, "FALL");
		// 等价于
		// se4 = SeasonEnum2.valueOf("FALL");

		// 使用compareTo()进行比较
		if (se1.compareTo(se2) < 0) {
			System.out.println(se1 + "在" + se2 + "之前");
		}
		// 使用equals()判断
		if (se3.equals(se4)) {
			System.out.println(se3 + "等于" + se4);
		}
		// 使用==判断
		if (se3 == se4) {
			System.out.println(se3 + "==" + se4);
		}

	}

}

上述代码中，equals()方法用于比较一个枚举实例值和任何其他现象，但只有这两个对象属于一个枚举类型且值也相同时，二者才会相等。比较两个枚举引用是否相等时可以直接使用“==”。