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 关键字