Java从入门到精通 第11章 枚举

 
　　快速归类整型常数——枚举
　　枚举是一个被命名的整型常数的集合。我们可以事先考虑到某一变量可能的取值，尽量用自然语言中含义清楚的单词来表示它的每一个值，这种方法称为枚举方法，用这种方法定义的类型称为枚举类型。

11.2 自定义的枚举

//如果没有枚举关键字，如何使用枚举功能
public class Color
{
	private String name;
	public static final Color RED=new Color("红色");
	public static final Color GREEN=new Color("绿色");
	public static final Color BLUE=new Color("蓝色");

	public String getName(){return name;}
	public void setName(String name){this.name=name);
	private Color(String name){setNmae(name);}
	
	public static Color getInstance(int i)
	{
		if(i==0){return RED;}
		if(i===1){return GREEN;);
		if(i==2){return BLUE;};
		return null;
	}
	
	public static void main(String[] args)
	{
		Color c1=new Color.getInstance(0);
		System.out.pritnln(c1.getName());
		Color c2=new Color.getInstance(1);
		System.out.println(c2.getName());
		Color c3=new Color.getInstance(2);
		System.out.prtinln(c3.getName());
	}
}

11.3.1 常见的枚举定义方法

//先定义后说明，变量a、b、c为枚举类型WeekDay
enum WeekDay{Mon,Tue,Wed,Thu,Fri,Sat,Sun};
enum WeekDay a,b,c;

//定义的同时说明
enum WeekDay{Mon,Tue,Wed,Thu,Fri,Sat,Sun}a,b,c;

//或者直接说明，无需枚举名
enum {Mon,Tue,Wed,Thu,Fri,Sat,Sun}a,b,c;

11.3.2 枚举的使用

enum MyColor{红色，绿色，蓝色};
public class EnumColor
{
	public static void main(String[] args)
	{
		MyColor c1=MyColor.红色;
		System.out.prtinln(c1）;
		MyColor c2=MyColor.绿色;
		System.out.prtinln(c2）;
		MyColor c2=MyColor.蓝色;
		System.out.prtinln(c3）;
	}
}

11.3.3 在switch语句中使用枚举

enum MyColr{红色,绿色,蓝色};
public class EnumSwitch
{
	public static void main(String[] args)
	{
		MyColor c1=MyColor.绿色;
		switch(c1)
		{
			case 红色:
			System.out.println("我是红色！");
			break;
			case 绿色:
			System.out.println("我是绿色！");
			break;
			case 蓝色:
			System.out.println("我是蓝色！");
			break;
		}
	}
}

11.4 枚举类和枚举关键字

	枚举类是在Java.lang包下定义的一个公共类，它的作用是用来构造新的枚举类型。
	枚举类中定义了十多个方法，每种方法都是对用Enum创建的对象实施操作

//通过调用Enum类中的方法ordinal()方法，输出枚举类型中的每一个对象编号
enum MyColor{红色,绿色,蓝色};
public class Test{
	public static void main(String[] args){
		MyColor[] allColor=MyColor.values();//用枚举数组读取枚举中的值
		for(MyColor aColor:allColor)
			System.out.println(aColor.name()+"-->"+aColor.ordinal());
	}
}

11.4.3 枚举类与枚举关键字的联系

实际上，使用enum关键字，相当于定义了一个类，该类继承自Enum类。而在Enum类中的方法，
访问权限都是Enum类中存在的Valueof（）方法，该方法返回带指定名称的指定枚举类型的枚举
常量，在下面的范例中，先用enum关键字定义了一个枚举对象Color,然后调用Enum类中的
valueOf()方法

enum Color{红色,绿色,蓝色};
public class Test{
	public static void main(String[] args){
		Color c=Color.valueOf(Color.class,"红色");
		System.out.println(c);
	}
}

	下面总结一下使用枚举类型的注意事项：
	（1）如果enum定义的枚举类访问权限定义为public，则需要单独形成一个.java文件，
即不可以与包含main方法的public类同处于一个文件爱你。如果enum定义的枚举类访问权限为
默认类型，即enum关键字前没有修饰符，则enum定义的对象可在同一个包里访问，无需重复定义
。例如前面的范例中都在一个包中，则所定义的枚举类型Color(MyColor)事实上仅需要在一个
.java文件定义即可，其他用到这个枚举类型的文件可以通过导入（import）来复用这个定义
	（2）使用enum定义的枚举类型默认继承于java.lang.Enum类。使用enum定义的枚举，
默认会使用final修饰，因此该类无法派生子类。
	（3）使用enum定义的枚举类，其所有值（实际上是该类的实例）必须在枚举类的第一行显
示列出，否则这个枚举类将永远不能产生实例。在列出这些实例时，系统会自动添加public 
static final修饰
	（4）所有使用enum定义的枚举类，都会由系统隐式提供一个valueOf（）方法，该方法
可以方便地遍历所有枚举值

11.5 类集对于枚举的支持

11.5.1 EnumMap

//使用EnumMap操作枚举类型中实例
import java.util.EnumMap;
import java.util.Map;
enum Color{红色,绿色,蓝色};
public class Test{
	public static void main(String[] args){
		EnumMap<Color,String> eMap=new EnumMap<Color,String>(Color.class);
		eMap.put(Color.红色,"RED");//添加EnumMap元素
		eMap.put(Color.绿色,"GREEN");
		eMap.put(Color.蓝色,"BULE");
		for(Map.Entry<Color,String> me:eMap.entrySet())
			System.out.println(me.getKey()+"-->"+me.getValue());
	}
}

11.5.2 EnumSet

import java.util.EnumSet;
import java.util.Iterator;
enum Color{红色,绿色,蓝色};
public class Test{
	public static void main(String[] args){
		//将枚举全部的内容设置到集合中
		EnumSet<Color> eSet=EnumSet.allOf(Color.class);
		Iterator<Color> iter=eSet.iterator();
		while(iter.hasNext())
			System.out.println(iter.next());
	}
}

//调用noneOf（）方法，对同样包含在EnumSet类中的不同方法的调用，来测试EnumSet方法
import java.util.EnumSet;
import java.util.Iterator;
enum Color{红色,绿色,蓝色};
public class Test{
	public static void main(String[] args){
		//表示此类型的空集合
		EnumSet<Color> eSet=EnumSet.noneOf(Color.class);
		Iterator<Color> iter=eSet.iterator();
		while(iter.hasNext())
			System.out.println(iter.next());
	}
}

11.6 深入了解枚举

11.6.1 枚举的构造方法

//NewColor定义的三个对象
enum NewColor{
	RED("红色",4),GREEN("绿色",5),BULE("蓝色",6);
	private String name;//成员变量
	private int index;
	private NewColor(String name,int index){
		this.name=name;
		this.index=index;
	}
	
	public static String getName(int index){
		for(NewColor c:NewColor.values())
			if(c.getIndex()==index)
				return c.name;
		return null;		
	}
	public String getName(){
		return name;
	}
	public static void setName(int index,String name){
		for(NewColor c:NewColor.values())
			if(c.getIndex()==index)
			{
				c.name=name;
				return;
			}			
	}
	public int getIndex(){
		return index;
	}
	public static void setIndex(int index,String name){
		for(NewColor c:NewColor.values())
			if(c.getName()==name)
			{
				c.index=index;
				return;
			}
	}
	
}	
public class Test{
	public static void main(String[] args){
		System.out.println("-----------输出枚举中的元素-----------");
		System.out.println(NewColor.RED.getIndex()+"--->"+NewColor.RED.getName());
		System.out.println(NewColor.GREEN.getIndex()+"--->"+NewColor.GREEN.getName());
		System.out.println(NewColor.BULE.getIndex()+"--->"+NewColor.BULE.getName());
		
		System.out.println("----在自定义编号和属性之后，测试-----");
		NewColor.setName(4,"黑色");//重新设置名称
		System.out.println("4--->"+NewColor.getName(4));
		NewColor.setIndex(7,"黑色");//重新设置索引编号
		System.out.println("7--->"+NewColor.getName(7));
	}
}

11.6.2 枚举的接口

public interface ColorInterface
{
	public String getColor();
}

//对新建接口抽象方法的调用。对接口中定义的抽象方法的调用，
//并且在后期声明的枚举类型中，任何一个对象都必须分别实现接口中的抽象方法
enum NewColor2 implements ColorInterface
{
	红色 //每个枚举对象都需要具体化从接口中继承的方法
	{
		public String getColor()
		{	
			return "RED";
		}
	}
	绿色 //每个枚举对象都需要具体化从接口中继承的方法
	{
		public String getColor()
		{	
			return "GREEN";
		}
	}
	蓝色 //每个枚举对象都需要具体化从接口中继承的方法
	{
		public String getColor()
		{	
			return "BLUE";
		}
	}
}

//测试上面的接口类型
public class TestColor
{
	public static void main(String[] args)
	{
		for(NewColor2 c:NewColor2.values())
			System.out.println(c.ordinal()+"-->"+c.name()+":"+c.getColor());
	}
}

11.6.3 在枚举中定义抽象方法

enum NewColor3
{
	红色//每个枚举对象都需要实现所定义的抽象方法
	{
		public String getColor()
		{	
			return "RED";
		}
	}
	绿色 
	{
		public String getColor()
		{	
			return "GREEN";
		}
	}
	蓝色 
	{
		public String getColor()
		{	
			return "BLUE";
		}
	}
	
	public abstract String getColor();//定义抽象方法
}
public class AbstractEnum
{
	public static void main(String[] args)
	{
		for(NewColor3 c:NewColor3.values))
			System.out.println(c.ordinal()+"-->"+c.name+":"+c.getColor());
	}
}

	1.枚举使用时的主义事项
	（1）枚举类型不能用public和protected修饰构造方法，构造方法的权限只能是private
或者friendly，friendly是没有修饰符的默认权限。因为枚举这种特性，所以枚举对象都是无
法在程序中通过直接调用其构造方法来初始化的
	（2）定义枚举类型时，如果是简单类型，那么最后一个枚举值后可以不加分号。但是如果
枚举中包含有方法，那么最后一个枚举值后面的代码必须用分号隔开
	2.枚举类型不可以被继承
	如果一个枚举类用abstract修饰，那么就说明需要其他类继承这个所谓的抽象枚举类，而
java中，规定枚举是不能被继承的，因此，枚举不能用abstract修饰，只能在枚举的实例实现
每个抽象方法