枚举类

1.一个类的对象是有限而且固定的，比如季节类，它只有四个对象。这种实例有限而且固定的类，在java里被称为枚举类。

2.枚举类和普通类的区别：

1）枚举类可以实现一个或多个接口，使用enum定义的枚举类默认继承了java.lang.Enum类，而不是Object类，其中java.lang.Enum类实现了java.lang.Serializable和java.lang.Comparable两个接口。

2）使用enum定义、非抽象的枚举类默认采用final修饰，因此枚举类不能派生子类。（注：抽象的枚举类默认采用abstract修饰，还是可以派生子类。）

3）枚举类的构造器只能使用private访问控制符，如果省略了构造器的访问控制符，则默认使用private，如果声明了访问控制符，则只能使用private。

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

3.

public enum season{
	spring,summer,autumn,winter;
}

public class seasontest{
	public void info(season a){
		switch(a)
		{
			case spring:
			System.out.println("春天");
			break;
			case summer:
			System.out.println("夏天");
			break;
			case autumn:
			System.out.println("秋天");
			break;
			case winter:
			System.out.println("冬天");
			break;
		}
	}
	public static void main(String[] args){
		for(season x:season.values()){				//通过values方法来返回该类所有的实例
			System.out.println(x);
		}
		new seasontest().info(season.summer);		//使用类名.实例的方式访问
	}
}
			

4.

public enum gender{
	man,woman;
	private String name;
	public void setname(String name){
		switch(this){				//this代表调用这个方法的实例，即man或者woman
			case man:
			if(name.equals("男")){
				this.name = name;
			}
			else{
				System.out.println("输入错误");
				return;
			}
			break;					//break不能漏
			case woman:
			if(name.equals("女")){
				this.name = name;
			}
			else{
				System.out.println("输入错误");
				return;
			}
			break;
		}
	}
	public String getname(){
			return this.name;
	}
}

public class gender2test{
	public static void main(String[] args){
		gender one = gender.valueOf("man");		//用valueOf方法获取指定的枚举值
		one.setname("女");
		one.setname("男");
		System.out.println(one.getname());
	}
}
	

5.如果将所有的成员变量都使用了final修饰，所以必须在构造器里为这些成员变量指定初始值，因此应该为枚举类显示定义带参数的构造器

public enum gender{
	man("男"),woman("女");       //man("男") 可以看作 public static final gender man = new gender("男");
	private final String name;
	private gender(String name){
		this.name=name;
	}
	public String getname(){
		return this.name;
	}
}

6.枚举类也可以实现一个或多个接口。与普通类一样，枚举类实现一个或多个接口的时候，必须实现该接口的所有抽象方法。

public interface genderexp{
	void info();
	default void into(){
		System.out.println("这是一个默认方法"); 
	}
}












public enum genderbase implements genderexp{
	man("男"){
		public void info(){
			System.out.println("代表男");
		}
	}, //注意 ，和；
	woman("女"){
		public void info(){
			System.out.println("代表女");
		}
	};
	private String name;
	private genderbase(String name){
		this.name = name;
	}
	public String getname(){
		return this.name;
	}
}

上面代码的粗体字部分看起来有些奇怪：当创建man和woman两个枚举值时，后面有紧跟了一对花括号，这对花括号里面包含了一个info()方法定义。花括号部分实际上是一个类体部分。当创建man、woman枚举值时，并不是直接创建gender枚举类的实例，而是相当于创建了gender的匿名子类的实例。编译程序，可以看见生成了genderbase.class、genderbase$1.class和genderbase$2.class。





7.
public enum count{
	add{
		public double eval(double x,double y){
			return x+y;
		}
	},
	reduce{
		public double eval(double x,double y){
			return x-y;
		}
	},
	mul{
		public double eval(double x,double y){
			return x*y;
		}
	},
	exc{
		public double eval(double x,double y){
			return x/y;
		}
	};
	public abstract double eval(double x,double y);		//为了让eval()方法有不同的实现，定义一个抽象方法。
	public static void main(String[] args){
		System.out.println(add.eval(3,4));
		System.out.println(reduce.eval(4,3));
		System.out.println(mul.eval(3,3));
		System.out.println(exc.eval(3,3));
	}
}
编译上面程序会生成五个class文件。定义抽象方法时，必须为每个枚举值都提供抽象方法的实现，否则编译错误。