枚举类Enum,EnumSet,EnumMap

EnumSet与HashSet相比，非常快。

 

 

public enum AlalmPoints{
	STAIR1, STAIR2， LOBBY， OFFICE1, OFFICE2;
}

public class EnumSets
{
	EnumSet<AlarmPoints> points =
		EnumSet.noneOf(AlarmPoint.class); //Enmpty set
	points.add(STAIR1);


}

 

 

 

EnumMap ，它要求其中的键(key)必须来自已个enum.

由于enum本身的限制，所以EnumMap在内部可由数组实现。

因此EnumMap的速度很快。不过只能将enum的实例作为键

来调用put()方法，如果key不存在，则对应null.

其他的操作与使用一般的Map差不多。

interface Command
{
	void actioin();
}

public class EnumMaps
{
	public static void main(String[] args){
		EnumMap<AlarmPoints, Command> em = 
			new EnumMap<AlarmPoints, Command>(AlarmPoints.class);
		em.put(KITCHEN, new Comman(){
			public void actioin(){
				System.out.println("Kitchen fire!");
			}
		});

		em.put(BATHROOM, new Comman(){
			public void actioin(){
				System.out.println("Bathroom fire!");
			}
		});
		for(Map.Entry<AlarmPoints, Command> e : em.entrySet()){
			system.out.println(e.getKey()+": ");
			e.getValue().action();
		}
		try{
			// If there;s no value for particular key;
			em.get(UTILITY).action();	//AlarmPoints 没有 UTILITY
		}catch(Exception e){
			...
		}
	}
}

 

常量相关方法

enum允许为enum实例编写方法， 从而为每个enum实例

赋予各自不同的行为。 要实现常量的相关的方法，

你需要为enum定义一个或多个abstract方法，

然后为每个enum实例实现该抽象方法。

public enum ConstantSpecificMethod{
	DATE_TIME{
		String getInfo(){
			return 
				DateFormat.getDateInstance().format(new Date());
		}
	},

	CLASSPATH{
		String getInfo(){
			return 
				System.getenv("CLASSPATH");
		}
	},
	VERSION{
		String getInfo(){
			return Syste.getProperty("java.version");
		}
	};

	abstract String getInfo();
	public static void main(String[] args){
		for(ConstantSpecificMethod csm : values())
			System.out.println(csm.getInfo());
	}
}

通过相应的enum实例，我们可以调用其上的方法。 这通常也称为表驱动的代码
在上面的例子中， enum实例视乎被当做"超类" ConstantSpecificMethod来使用，
在调用getInfo()方法时，体现出多态的行为。
	然而， enum实例与类的相似之处也仅限于此。
	我们并不能真的将enum实例作为一个类型来使用

enum LikeClass{
	WINKEN{void behavior(){sysout("B1")}},
	BLINKEN{void behavior(){sysout("B2")}},
	abstract void behavior();
}
public class NotClasses
{
	// void f1(LikeClass.WINKEN insatnce){} //OPE 
}
// 
Compiled form "NotClasses.java"
abstract class LikeClasses extends java.lang.Enum
{
	public static final LikeClasses WINKEN;
	public static final LikeClasses BLINKEN;
	public static final LikeClasses NOD;

在方法f1()中，编译器不允许我们将以个enum实例当做class类型，
分析下编译器生成的代码，就知道每个enum元素都是一个LikeClasses
类型的static final实例。

同时，由于他们是 static 实例，无法访问外部类的非static元素或
方法，所以对于内部的enum的实例而言，行为跟一般的内部类并不相同。

	public class CarWash {
	public enum Cycle{
		UNDERBODY{
			void action(){ System.out.println("underbody");}
		},
		WHEELWASH{
			void action(){ System.out.println("Washing the wheels");}
		};
		abstract void action();
	}
	
	EnumSet<Cycle> cycles =
		EnumSet.of(Cycle.UNDERBODY, Cycle.WHEELWASH);
	
	public void washCar(){
		for(Cycle c : cycles)
			c.action();
	}
	
	public static void main(String[] args){
		CarWash wash = new CarWash();
		System.out.println(wash);
		wash.washCar();
		wash.cycles.add(Cycle.UNDERBODY);
	}
}

 

与使用匿名内部类相比， 定义常量相关方法的语法更高效，简洁。

这个例子展示 EnumSet一些特性，因为她是一个恶集合，所以对一个

元素而言，只能出现一次。想EnumSet添加的enum实例的顺序并不重要，

因为其输出的次序决定于enum实例定义时的次序。

除了实现abstract方法外， 还可以覆盖常量的相关方法

public enum OverrideConstantSpecific{
	NUT, BOLT,
	WASHER{
		void f(){print("Overriden method");}
	};
	void f(){print("default method");}

	public static void mian(String[] args){
		for(OverrideConstantSpecific osc : values()){
			print(osc+":");
			ocs.f();
		}
	}
}
//output
NUT : default method;
BOLT : default method;
WASHER : Overriden method;