java语言学习之枚举类

一.枚举类
枚举类是一种特殊的类，它一样可以有自己的成员变量，方法，可以实现一个或者多个接口，也可以定义自己的构造器。一个Java源文件中最多只能定义一个public访问权限的枚举类，且该Java源文件也必须和该枚举类的类名相同。

1.枚举类与普通类区别:
1.枚举类可以实现一个或多个接口，使用enum定义的枚举默认继承了java.lang.Enum类，而不是默认继承Object类，因此枚举类不能显示继承其他父类，其中java.lang.Enum类实现了java.lang.Serializable和java.lang.Comparable两个接口。

2.使用enum定义，非抽象的枚举类默认会使用final修饰，因此枚举类不能派生子类。

3.枚举类的构造器只能使用private访问控制符，如果省略了构造器的访问控制符，则默认使用private修饰；如果强制指定访问控制符，则只能指定private修饰符。

4.枚举类的所有实例必须在枚举类的第一行显式列出，否则这个枚举类永远都不能产生实例。列出这些实例时，系统会自动添加public static final修饰，无须程序员显示添加。

枚举类默认提供了一个values()方法，该方法可以很方便地遍历所有的枚举值。
下面程序定义了一个SeasonEnum枚举类。

public enum SeasonEnum {
	// 在第一行列出4个枚举实例
	SPRING,SUMMER,FALL, WINTER;
}

public class EnumTest
{
	public void judge(SeasonEnum s)
	{
		// switch语句里的表达式可以是枚举值
		switch (s)
		{
			case SPRING:
				System.out.println("春暖花开，正好踏青");
				break;
			case SUMMER:
				System.out.println("夏日炎炎，适合游泳");
				break;
			case FALL:
				System.out.println("秋高气爽，进补及时");
				break;
			case WINTER:
				System.out.println("冬日雪飘，围炉赏雪");
				break;
		}
	}
	public static void main(String[] args)
	{
		// 枚举类默认有一个values方法，返回该枚举类的所有实例
		for (SeasonEnum s : SeasonEnum.values())
		{
			System.out.println(s);
		}
		// 使用枚举实例时，可通过EnumClass.variable形式来访问
		new EnumTest().judge(SeasonEnum.SPRING);
	}
}

结果:

SPRING
SUMMER
FALL
WINTER
春暖花开，正好踏青

所有的枚举类都继承了java.lang.Enum类，所以枚举类可以直接使用java.lang.Enum类中所包含的方法。

//枚举对象之间比较
int compareTo(E o);
//返回此枚举实例的名称
String name();
//返回枚举常量的名称，与name方法类似，但toString()方法更常用。
int ordinal();

二.枚举类的成员变量，方法和构造器
和普通类差别在于产生Gender对象的方式不同，枚举类的实例只能是枚举值，而不是随意地通过new来创建枚举类对象。

Gender.java

public enum Gender
{
	MALE,FEMALE;
	private String name;
	public void setName(String name)
	{
		switch (this)
		{
			case MALE:
				if (name.equals("男"))
				{
					this.name = name;
				}
				else
				{
					System.out.println("参数错误");
					return;
				}
				break;
			case FEMALE:
			if (name.equals("女"))
			{
				this.name = name;
			}
			else
			{
				System.out.println("参数错误");
				return;
			}
			break;
		}
	}
	public String getName()
	{
		return this.name;
	}
}

GenderTest.java

public class GenderTest
{
	public static void main(String[] args)
	{
		Gender g = Gender.valueOf("FEMALE");
		//方式二:通过Enum的valueof方法来获取指定枚举类的枚举值
		//Gender g = Enum.valueOf(Gender.class, "FEMALE");
		g.setName("女");
		System.out.println(g + "代表:" + g.getName());
		// 此时设置name值时将会提示参数错误。
		g.setName("男");
		System.out.println(g + "代表:" + g.getName());
	}
}

实际上这种做法依然不够好，枚举类通常应该设计成不可变类，因此将枚举类的成员变量都使用private final修饰。如果将所有成员变量都是用了final修饰符来修饰，那么必须在构造器里为这些成员变量指定初始值(或在定义成员变量时指定默认值，或在在初始化块中指定初始值，但这两种并不常见) 因此应该为枚举类显式定义带参数的构造器。

一旦为枚举类显示定义了带参数的构造器，列出枚举值时就必须对应地传入参数

public enum Gender
{
	// 此处的枚举值必须调用对应构造器来创建
	MALE("男"),FEMALE("女");
	private final String name;
	// 枚举类的构造器只能使用private修饰
	private Gender(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}
}

MALE(“男”),FEMALE(“女”); 在枚举类中列出枚举值时，实际上就是调用构造器创建枚举类对象，只是这里无须使用new关键字，也无须显式调用构造器。
上面的代码如同：

public static final Gender MALE = new Gender("男");
public static final Gender FEMALE = new Gender("女");

二.实现接口的枚举类
与普通类实现一个或多个接口完全一样.实现一个或多个接口时，也需要实现该接口所包含的方法。

public interface GenderDesc
{
	void info();
}

public enum Gender implements GenderDesc
{
	// 此处的枚举值必须调用对应构造器来创建
	MALE("男")
	// 花括号部分实际上是一个类体部分
	{
		public void info()
		{
			System.out.println("这个枚举值代表男性");
		}
	},
	FEMALE("女")
	{
		public void info()
		{
			System.out.println("这个枚举值代表女性");
		}
	};
	// 其他部分与codes\06\6.9\best\Gender.java中的Gender类完全相同
	private final String name;
	// 枚举类的构造器只能使用private修饰
	private Gender(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}
	// 增加下面的info()方法，实现GenderDesc接口必须实现的方法
	public void info()
	{
		System.out.println(
			"这是一个用于用于定义性别的枚举类");
	}
}

三.包含抽象方法的枚举类

public enum Operation
{
	PLUS
	{
		public double eval(double x , double y)
		{
			return x + y;
		}
	},
	MINUS
	{
		public double eval(double x , double y)
		{
			return x - y;
		}
	},
	TIMES
	{
		public double eval(double x , double y)
		{
			return x * y;
		}
	},
	DIVIDE
	{
		public double eval(double x , double y)
		{
			return x / y;
		}
	};
	// 为枚举类定义一个抽象方法
	// 这个抽象方法由不同的枚举值提供不同的实现
	public abstract double eval(double x, double y);
	public static void main(String[] args)
	{
		System.out.println(Operation.PLUS.eval(3, 4));
		System.out.println(Operation.MINUS.eval(5, 4));
		System.out.println(Operation.TIMES.eval(5, 4));
		System.out.println(Operation.DIVIDE.eval(5, 4));
	}
}

枚举类里定义抽象方法时不能使用abstract关键字将枚举类定义成抽象类(系统自动会为它添加abstract关键字)，枚举类需要显式创建枚举值，而不是作为父类，所以定义每个枚举值时必须为抽象方法提供实现，否则编译出现编译错误。