Java中枚举类型简单学习

/*
 * enum类型不允许继承
 * 除了这一点，我们基本上可以将enum看作一个常规的类
 * 我们可以添加自己的方法与属性，我们也可以覆盖其中的方法。
 * 不过一定要在enum实例序列的最后添加分号
 */
enum Hot{
	LITTLE("litele hot"), MEDIEM("mediem hot"), HOT("very hot");
	/*
	 * 添加自己的属性和方法
	 */
	private String des;
	private Hot(String s) {
		des = s;
	}
	public String getDes() {
		return des;
	}
	//重新toString()
	@Override
	public String toString() {
		return name() + " : " + name().toLowerCase();
	}
	
}

public class Test{
	
	public static void Select(Hot hot) {
		switch(hot) {
			case LITTLE: {
				System.out.println(hot.toString());
				break;
			}
			case MEDIEM: {
				System.out.println(hot.toString());
				break;
			}
			case HOT: {
				System.out.println(hot.toString());
			}
		}
	}
	
	public static void main(String[] args) {
		
		for (Hot hot : Hot.values()) {
			System.out.println(hot + " : ordinal : " + hot.ordinal());
			System.out.println(hot.compareTo(Hot.HOT));
			System.out.println(hot.equals(Hot.HOT));
			System.out.println((hot == Hot.HOT));
			System.out.println(hot.getDeclaringClass());
			System.out.println(hot.name());
			System.out.println("description : " + hot.getDes());
			System.out.println("--------------------------");
		}
		for (String s : "LITTLE MEDIEM HOT".split(" ")) {
			Hot hot = Hot.valueOf(Hot.class, s);
			System.out.println(hot.getDeclaringClass() + " : " + hot.toString());
		} 
		System.out.println("----------------------------");
		
		/*
		 * enum天生就是符合switch的
		 */
		Select(Hot.HOT);
		
	}
}

　　

 定义枚举的枚举：

import java.util.Random;

/*
 * 如何定义枚举的枚举，我们可以通过枚举的枚举，对类型进行分类
 */

/*
 * 首先定义一个工具类来随机生成枚举的类型
 */
class EnumsUtils {
	private static Random random = new Random(47);
	//接收一个Enum类型的Class
	public static <T extends Enum<T>> T random(Class<T> sc) {
		return random(sc.getEnumConstants());
	}
	//接收Enum实例的数组
	public static <T> T random(T[] values) {
		return values[random.nextInt(values.length)];
	}
}

/*
 * 定义枚举的枚举
 */
enum Meal{
	APPETIZER(Food.Appetizer.class),
	MAINCOURSE(Food.MainCourse.class); //注意分号
	
	private Food[] values; //每一个Enum实例的所包含的Ｅｎｕｍ实例
	private Meal(Class<? extends Food> kind) {
		values = kind.getEnumConstants();
	}
	//非分类
	public interface Food{
		//开胃菜
		enum Appetizer implements Food{
			//莴苣, 
			SALAD, SOUP,SPRING_ROLLS
		}
		enum MainCourse implements Food{
			LASAGNE, BURRITO,PAD_THAI
		}
	}
	
	public Food randomSelect() {
		return EnumsUtils.random(values);
	}
	
}
public class Test{

	public static void main(String[] args) {
		for (int i = 0; i < 5; ++i) {
			System.out.println("第" + (i + 1) + "套餐:" );
			for (Meal meal : Meal.values()) {
				Meal.Food food = meal.randomSelect();
				System.out.println(food);	
			}
		}
	}
}

输出：
第1套餐:
SPRING_ROLLS
PAD_THAI
第2套餐:
SOUP
PAD_THAI
第3套餐:
SOUP
PAD_THAI
第4套餐:
SOUP
PAD_THAI
第5套餐:
SALAD
BURRITO

　　

 通过定义与常量有关的方法我们可以实现多态， 我们同时还可以在实例中覆盖方法：

import java.util.EnumSet;
/*
 * 常量相关的方法，实现多态
 * 覆盖常量相关的方法
 * 中间我们还要用到EnumSet ， 还有EnumMap ， 他们查看API就可以了
 */
public class Test{

	enum Hot{
		//各自实现自己的description（）
		LITTLE {
			@Override
			void description() {
				System.out.println("little hot ...");
			}
		},
		MEDIM {
			@Override
			void description() {
				System.out.println("Medim hot  ...");
			}
		},
		HOT {
			@Override
			void description() {
				System.out.println("hot hot ....");
			}
			//可以覆盖自己的方法
			public void show() {
				System.out.println("very hot..");
			}
		};
		//抽象方法， 实现多态
		abstract void description();
		public void show() {
			System.out.println("hot ..hot ..");
		}
	}
	EnumSet<Hot> hots = EnumSet.of(Hot.MEDIM, Hot.LITTLE);
	public void add(Hot hot) {
		hots.add(hot);
	}
	public void traverse() {
		for (Hot e : hots) {
			System.out.print("e.description() : "); e.description();
			System.out.print("e.show() : ");  e.show();
		}
	}
	public static void main(String[] args) {
		Test test = new Test();
		test.traverse();
		System.out.println("------------");
		
		test.add(Hot.MEDIM); test.add(Hot.MEDIM);
		test.add(Hot.HOT);
		test.traverse();
		
	}
}

输出：
e.description() : little hot ...
e.show() : hot ..hot ..
e.description() : Medim hot  ...
e.show() : hot ..hot ..
------------
e.description() : little hot ...
e.show() : hot ..hot ..
e.description() : Medim hot  ...
e.show() : hot ..hot ..
e.description() : hot hot ....
e.show() : very hot..