JAVA枚举类

1、枚举的基本使用    

    枚举类不使用class而是用enum来声明，枚举类是一种特殊的类，它自动继承自抽象类Enum。一个源文件中只能定义一个public枚举类，且类名也必须与源文件名相同。我们一般使用枚举来声明类型：

/***** Action.java文件 *****/
public enum Action{
    LEFT, RIGHT, UP, DOWN, NONE
}

/***** Game.java *****/
public class Game{
    public static void play(Action ac)
    {
        switch(ac)
        {
            case LEFT:
                ...
                break;
            case RIGHT:
                ...
                break;
            case UP:
                ...
                break;
            case DOWN:
                ...
                break;
            case NONE:
                ...
                break;
            default:
                ...
                break;
        }
    }

    public static void main(String[] args)throws Exception{
      Action ac = Action.LEFT;
      play(ac);
    }
}

2、枚举的扩展使用  

    枚举的实例必须放在第一行显示列出，其类型只能而且默认是public static final类型，如下所示：

enum SeasonEnum
{
    SPRING, SUMMER, FALL, WINTER; //枚举实例
    SeasonEnum(){}
}

    枚举类继承自java.lang.Enum类而非Object，Enum类包含方法有compareTo、name、toString、ordinal、valueOf等，如下所示。不可以在枚举类的构造方法中调用super()。

   Enum的qeuals()、hashCode()基本上继承了Object的行为，但被标识为final。

    枚举类中还包含一个默认的方法values()，他可以返回一个包含所有枚举实例的数组。

    普通的枚举类默认是final类型，所以不能派生子类，特殊情况是包含抽象方法的枚举类，它不是final类型。

    枚举类的构造器只能而且默认是private，所以只能在枚举类内实例化对应枚举对象，枚举类的实例只能是枚举值，不能通过new来创建枚举对象。

    枚举类通常应该设计成不可变类，因此里面的成员变量应该设置成final类型，所以必须在构造器中为成员变量指定初始值。

    枚举类可以实现一个或多个接口。

interface Desc
{
	public void info();
}

enum SeasonEnum implements Desc
{
	SPRING("春"), SUMMER("夏"), FALL("秋"), WINTER("冬"); //因为在下面我们定义了带一个String参数的构造方法，所以这里可以为枚举实例赋值进行构造
	SeasonEnum(String chs){this.chs = chs;}
	public void info(){System.out.println("枚举类SeasonEnum");}
    public final String chs;
}

public class Test
{
	void test(SeasonEnum e)
	{
		switch(e)
		{
			case SPRING:
			break;
			case SUMMER:
			break;
			case FALL:
			break;
			case WINTER:
			break;
		}
	}
	public static void main(String[] aggs)
	{
		for(SeasonEnum s: SeasonEnum.values())
		{
			System.out.println(s);
		}
		int diff = SeasonEnum.FALL.compareTo(SeasonEnum.SPRING); //位置差值，可以为负数，这里的diff为2
		String str = SeasonEnum.FALL.toString(); //获得枚举声明的时候使用的名称str为"FALL"
		str = SeasonEnum.FALL.name(); //同toString，但JDK上推荐使用toString，str为"FALL"
		int idx = SeasonEnum.SPRING.ordinal(); //获得位置索引，idx为0
		SeasonEnum s = Enum.valueOf(SeasonEnum.class, "SUMMER"); //通过枚举名称获得枚举值
		s.info(); //输出"枚举类SeasonEnum"
	}
}

    在上面的例子中，使用枚举实例调用实现的接口方法info的时候所有枚举实例实际都是相同的行为，如果想要每个实例调用接口方法的时候呈现不同的行为，那可以将枚举类修改为以下方式：

interface Desc
{
    public void info();
}

enum SeasonEnum implements Desc
{
    SPRING("春")
            {
                public void info(){System.out.println("枚举类SeasonEnum的实例：SPRING(春)");}
            },
    SUMMER("夏")
            {
                public void info(){System.out.println("枚举类SeasonEnum的实例：SUMMER(夏)");}
            },
    FALL("秋")
            {
                public void info(){System.out.println("枚举类SeasonEnum的实例：FALL(秋)");}
            },
    WINTER("冬")
            {
                public void info(){System.out.println("枚举类SeasonEnum的实例：WINTER(冬)");}
            };
    public final String chs;
    SeasonEnum(String chs){this.chs = chs;}
}

public class Main {
    public static void main(String[] args)throws Exception{
        SeasonEnum en = SeasonEnum.SUMMER;
        en.info(); //输出为"枚举类SeasonEnum的实例：SUMMER(夏)"
    }
}

  特定值类本体语法不仅在操作接口时可以使用，也可以运用在重新定义父类方法：

enum SeasonEnum
{
    SPRING {
            public String toString(){ return "春天"; }
            },
    SUMMER {
            public String toString(){ return "夏天"; }
            }
    ......
}

  对于上面的代码，实际上编译器会将枚举类SeasonEnum标识为抽象类，并为每个枚举实例后的{}语法产生匿名内部类，这些匿名内部类继承了SeasonEnum并操作了info()方法，每个枚举实例实际上都是SeasonEnum的匿名子类对象，如下所示：

interface Desc
{
    public void info();
}

abstract class SeasonEnum extends Enum implements Desc
{
    static
    {
        SPRING = new SeasonEnum("春"){
            public void info(){System.out.println("枚举类SeasonEnum的实例：SPRING(春)");}
        };
        SUMMER = new SeasonEnum("夏"){
            public void info(){System.out.println("枚举类SeasonEnum的实例：SUMMER(夏)");}
        };
        ......
    }
    ......
}

  

    枚举类中也可以包含抽象方法，因为枚举实例类是枚举类的子类，所以可以在其中对抽象方法进行各自的实现：

public enum Operation
{
	PLUS
	{
		public double eval(double x, double y)
		{
			return x + y;
		}
	},
	MINUS
	{
		public double eval(double x, double y)
		{
			return x - y;
		}
	},
	TIMES
	{
		public double eval(double x, double y)
		{
			return x * y;
		}
	},
	DIVIDE
	{
		public double eval(double x, double y)
		{
			return x / y;
		}
	};
	public abstract double eval(double x, double y);
	
	public static void main(String[] args)
	{
		System.out.println(Operation.PLUS.eval(3, 4)); //输出 7.0
		System.out.println(Operation.TIMES.eval(3, 4)); //输出 12.0
	}
}