java 枚举

//枚举
声明枚举类型
[public] enum 枚举类型名{
	枚兴成员1,枚举成员2,....;
}
所有的枚举类型隐性地继承了 java.lang.Enum
// ===============
//定义枚举类型
enum Directions
{
	EAST,NORTH,WEST,SOUTH;
}
public class Hi
{
	public static void main(String[] args)
	{
		Directions dir = Directions.EAST;
		System.out.println("获取的枚举成员："+dir);
	}
}
//获取的枚举成员：EAST
// ================
枚举类: Enum
java.lang.Enum 类的定义如下：
public abstract class Enum<E extends Enum<E>>
extends Object implements Comparable<E>,Serializable

常用方法
//以接收枚举的名称和枚举的常量创建枚举对象
protected Enum(String name, int ordinal)

//克隆枚举对象
protected Object clone()

//比较此枚举与指定对象的顺序
public int compareTo(E o)

//比较两个枚举对象是否相等
public boolean equals(Object other)

//返回与指定枚举常量的枚举类型相同的 Class对象
public class<E> getDeclaringClass()

//返回枚举常量的哈希码
public int hashCode()

//返回枚举常量的名称
public String name()

//返回枚举量的序数
public int ordinal()

//返回枚举常量的名称
public String toString()

//返回带指定名称的指定枚举类型的枚举常量
public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name)
// ==================
枚举类型的 values()方法
enum Directions
{
	EAST,WEST,NORTH,SOUTH;
}
public class Hi
{
	public static void main(String[] args)
	{
		System.out.println("使用循环方式输出");
		for(int i=0; i<Directions.values().length; i++)
		{
			System.out.println("枚举成员："+Directions.values()[i]);
		}
		System.out.println("使用foreach输出");
		for(Directions dir: Directions.values())
		{
			System.out.println("枚举成员："+dir);
		}
	}
}
/*
使用循环方式输出
枚举成员：EAST
枚举成员：WEST
枚举成员：NORTH
枚举成员：SOUTH
使用foreach输出
枚举成员：EAST
枚举成员：WEST
枚举成员：NORTH
枚举成员：SOUTH
*/

// ===============

//获取枚举成员的名称和索引
enum Directions
{
	EAST,WEST,NORTH,SOUTH;
}
public class Hi
{
	public static void main(String[] args)
	{
		System.out.println("使用循环输出");
		for(int i=0; i<Directions.values().length; i++)
		{
			System.out.println("索引位置："+Directions.values()[i].ordinal()+
					",枚举成员名称："+Directions.values()[i].name());
		}
		System.out.println("使用foreach方式");
		for(Directions dir: Directions.values()){
			System.out.println("索引位置："+dir.ordinal()+"，成员名称："+dir.name());
		}
	}
}
/*
使用循环输出
索引位置：0,枚举成员名称：EAST
索引位置：1,枚举成员名称：WEST
索引位置：2,枚举成员名称：NORTH
索引位置：3,枚举成员名称：SOUTH
使用foreach方式
索引位置：0，成员名称：EAST
索引位置：1，成员名称：WEST
索引位置：2，成员名称：NORTH
索引位置：3，成员名称：SOUTH
*/
// =================
枚举类的构造方法与 valueof()方法
枚举类型对象属性
enum Directions
{
	// 定义枚举成员
	EAST("东"),WEST("西"),NORTH("北"),SOUTH("南");
	/*
	 * EAST("东")相当于
	 * public static final Directions EAST = new Directions("东");
	 */
	private String name;
	private Directions(){this(null);}
	private Directions(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		for(Directions dir:Directions.values())
		{
			System.out.println("索引位置："+dir.ordinal()+",枚举成员名："+dir.name()+
					",说明信息："+dir.getName());
		}
	}
}
/*
索引位置：0,枚举成员名：EAST,说明信息：东
索引位置：1,枚举成员名：WEST,说明信息：西
索引位置：2,枚举成员名：NORTH,说明信息：北
索引位置：3,枚举成员名：SOUTH,说明信息：南
*/
// ====================
使用 setter方法设置枚举成员的属性
enum Directions
{
	EAST,WEST,SOUTH,NORTH;
	private String name;
	public void setName(String name)
	{
		switch(this)
		{
		case EAST:
			if(name.equals("东"))
			{
				this.name = name;
			}else
			{
				System.out.println("设置EAST错误");
				return ;
			}
			break;
		case SOUTH:
			if(name.equals("南"))
			{
				this.name = name;
			}else
			{
				System.out.println("设置SOUTH错误");
				return ;
			}
			break;
		case WEST:
			if(name.equals("西"))
			{
				this.name = name;
			}else
			{
				System.out.println("设置WEST错误");
				return ;
			}
			break;
		case NORTH:
			if(name.equals("北"))
			{
				this.name = name;
			}else
			{
				System.out.println("设置 NORTH错误");
				return ;
			}
			break;
		}
	}
	public String getName()
	{
		return name;
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Directions dir = Directions.SOUTH;
		dir.setName("南");
		System.out.println("属性："+dir.getName());
		dir.setName("右");
		System.out.println("属性："+dir.getName());
	}
}
/*
属性：南
设置SOUTH错误
属性：南
*/
// ======================
类集的枚举操作： EnumMap和EnumSet
import java.util.Set;
import java.util.Map;
import java.util.EnumMap;
import java.util.Iterator;
enum Directions
{
	WEST,NORTH,EAST,SOUTH;
}
public class Hi
{
	public static void main(String[] args)
	{
		EnumMap<Directions, String> enummap = null;
		enummap = new EnumMap<Directions,String>(Directions.class);
		enummap.put(Directions.EAST, "东");
		enummap.put(Directions.WEST,"西");
		enummap.put(Directions.NORTH, "北");
		enummap.put(Directions.SOUTH, "南");
		Set<Map.Entry<Directions, String>> set = enummap.entrySet();
		Iterator<Map.Entry<Directions, String>> it = set.iterator();
		while(it.hasNext())
		{
			Map.Entry<Directions, String> me = it.next();
			System.out.println(me.getKey()+"---->"+me.getValue());
		}
	}
}
/*
WEST---->西
NORTH---->北
EAST---->东
SOUTH---->南
*/

// --------------
EnumSet类常用方法
//向集合中添加元素
public boolean add(E e)

//创建一个包含指定元素类型的所有元素的EnumSet对象
public static <E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType)

//创建一个其元素类型与指定 EnumSet集合s相同的 EnumSet集合，包含s中所不包含的此类型的所有元素
public static <E extends Enum<E>> EnumSet<E> complementOf(EnumSet<E> s)

//创建一个从指定collection集合c 初始化的EnumSet集合，包含c中所有元素
public static <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c)

//创建一个其元素类型与指定EnumSet集合s相同的EnumSet集合，包含相同的元素(如果存在)
public static <E extends Enum<E>> EnumSet<E> copyOf(EnumSet<E> s)

//创建Iterator实例
public abstract Iterator<E> iterator()

//创建一个具有指定元素类型的空EnumSet集合
public static <E extends Enum<E>> EnumSet<E> noneOf(Class <E> elementType)

//创建包含指定元素的对象
public static <E extends Enum<E>> EnumSet<E> of(E e1,E e2,..)
//创建一个最初包含由两个指定端点所定义范围内的所有元素 EnumSet集合
public static <E extends Enum<E>> EnumSet<E> range(E from, E, to)

//从集合中删除指定元素
public boolean remove(Object o)
// ====================
向集合中添加元素
import java.util.Set;
import java.util.EnumSet;
import java.util.Iterator;
enum Directions
{
	EAST,SOUTH,WEST,NORTH;
}
public class Hi
{
	public static void main(String[] args)
	{
		EnumSet<Directions> enumset1 = null;
		//将枚举类型添加到集合
		enumset1 = EnumSet.allOf(Directions.class);
		System.out.println("**enumset1 = EnumSet.allOf(Directions.class)**");
		show(enumset1);
		EnumSet<Directions> enumset2 = null;
		// 建立空的 EnumSet对象 enumset2
		enumset2 = EnumSet.noneOf(Directions.class);
		// 添加元素
		enumset2.add(Directions.EAST);
		enumset2.add(Directions.WEST);
		enumset2.add(Directions.SOUTH);
		enumset2.add(Directions.NORTH);
		System.out.println("enumset2 = EnumSet.noneOf(Directions.class)和add()");
		show(enumset2);
		EnumSet<Directions> enumset3 = null;
		enumset3 = EnumSet.noneOf(Directions.class);
		enumset3.addAll(enumset1);
		System.out.println("enumset3 = EnumSet.noneOf(Directions.calss)和addAll()");
		show(enumset3);
		
	}
	public static void show(EnumSet enumset)
	{
		Iterator<Directions> it = enumset.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}
/*
**enumset1 = EnumSet.allOf(Directions.class)**
EAST
SOUTH
WEST
NORTH
enumset2 = EnumSet.noneOf(Directions.class)和add()
EAST
SOUTH
WEST
NORTH
enumset3 = EnumSet.noneOf(Directions.calss)和addAll()
EAST
SOUTH
WEST
NORTH
*/
// ===============

//
of():创建一个包含指定元素的集合
copyOf():将指定集合中所有的元素复制到另一个集合中
range():从两个端点所指定的位置开始复制
import java.util.Set;
import java.util.EnumSet;
import java.util.Iterator;
enum Directions
{
	EAST,SOUTH,WEST,NORTH;
}
public class Hi
{
	public static void main(String[] args)
	{
		EnumSet<Directions> enumset1 = null;
		//创建包含指定元素的 EnumSet对象
		enumset1 = EnumSet.of(Directions.EAST,Directions.SOUTH);
		System.out.println("**enumset1=EnumSet.of(Directions.EAST,Directions.SOUTH) **");
		show(enumset1);
		EnumSet<Directions> enumset2 = null;
		// 复制指定Enumset中的元素
		enumset2 = EnumSet.copyOf(enumset1);
		System.out.println("**enumset2 = Enumset.copyOf(enumset1)**");
		show(enumset2);
		EnumSet<Directions> enumset3 = null;
		// 创建包含指定元素的对象
		enumset3 = EnumSet.range(Directions.SOUTH, Directions.NORTH);
		System.out.println("**enumset3 = EnumSet.range(Directions.SOUTH,Directions.NORTH)");
		show(enumset3);
	}
	public static void show(EnumSet enumset)
	{
		Iterator<Directions> it = enumset.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}
/*
**enumset1=EnumSet.of(Directions.EAST,Directions.SOUTH) **
EAST
SOUTH
**enumset2 = Enumset.copyOf(enumset1)**
EAST
SOUTH
**enumset3 = EnumSet.range(Directions.SOUTH,Directions.NORTH)
SOUTH
WEST
NORTH
*/

// ===================
// 枚举类与接口
枚举成员后面的花括号实际上是类体部分，枚举类中的枚举成员是枚举中的匿名内部子类
interface EnumInterface
{
	// 定义抽象方法
	void show();
}
// 定义枚举类型，并实现 EnumInterface接口
enum Directions implements EnumInterface
{
	EAST(){
		// 枚举成员需要实现接口中的抽象方法 show()
		public void show()
		{
			System.out.println("此枚举成员为东");
		}
	},
	SOUTH()
	{
		public void show()
		{
			System.out.println("此枚举成员为南");
		}
	},
	WEST()
	{
		public void show()
		{
			System.out.println("此枚举成员为西");
		}
	},
	NORTH()
	{
		public void show()
		{
			System.out.println("此枚举成员为北");
		}
	};
}
public class Hi
{
	public static void main(String[] args)
	{
		for(Directions dir:Directions.values())
		{
			dir.show();
		}
	}
}
/*
此枚举成员为东
此枚举成员为南
此枚举成员为西
此枚举成员为北
*/
// ================

枚举类与抽象方法
在枚举类中定义抽象方法
enum Directions
{
	// 枚举成员
	EAST()
	{
		// 枚举成员需要实现的抽象方法
		public void show()
		{
			System.out.println("此枚举成员为东");
		}
		public String getDirections()
		{
			return "东";
		}
	},
	SOUTH()
	{
		public void show()
		{
			System.out.println("此枚举成员为南");
		}
		public String getDirections()
		{
			return "南";
		}
	},
	WEST()
	{
		public void show()
		{
			System.out.println("此枚举成员为西");
		}
		public String getDirections()
		{
			return "西";
		}
	},
	NORTH()
	{
		public void show()
		{
			System.out.println("此枚举成员为北");
		}
		public String getDirections()
		{
			return "北";
		}
	};
	// 定义抽象方法
	public abstract void show();
	public abstract String getDirections();
}
public class Hi
{
	public static void main(String[] args)
	{
		for(Directions dir:Directions.values())
		{
			dir.show();
			System.out.println("属性为:"+dir.getDirections());
		}
	}
}
/*
此枚举成员为东
属性为:东
此枚举成员为南
属性为:南
此枚举成员为西
属性为:西
此枚举成员为北
属性为:北
*/
可以看到，在枚举类定义抽象类，不需要显式使用abstract 关键字