关于Java-枚举的总结

　　枚举

枚举的定义

　　枚举也是JDK5.0的新特性。

　　JDK5.0加入了一个全新类型的“类”——枚举类型。

　　为此引入了一个新的关键字enum。

　　可以这样来定义一个枚举类型：

public enum Color
{
    Red, White, Blue,
}

　　然后可以这样来使用：

Color myColor = Color.Red;

枚举类型的静态方法

　　枚举类型提供了两个有用的静态方法values()和valueOf()。

　　values()返回枚举所有成员的数组。

　　values()方法的使用：

        //values()方法的使用
        for(Color color : Color.values())
        {
            System.out.println(color);
        }

　　将输出：

　　Red
　　White
　　Blue
　　即values()输出定义在Color中的所有枚举类型。

　　而valueOf()将字符串转换成枚举值。

枚举的使用

　　枚举可以用在switch语句中。

　　例子： 　　

public class EnumTest
{
    public static void doOperation(OpConstant opConstant)
    {
        switch (opConstant)
        {
        case TURN_LEFT:
            System.out.println("向左转");
            break;
        case TURN_RIGHT:
            System.out.println("向右转");
            break;
        case SHOOT:
            System.out.println("射击");
            break;
        default:
            break;
        }

    }

    public static void main(String[] args)
    {
        doOperation(OpConstant.SHOOT);
    }

}

enum OpConstant
{
    TURN_LEFT, TURN_RIGHT, SHOOT,
}

枚举的本质

　　先看一个例子：　　

public enum Coin
{
    penny("hello"), nickle("world"), dime("welcome"), quarter("hello world");

    private String value;

    public String getValue()
    {
        return value;
    }
    Coin(String value)
    {
        this.value = value;
    }

    public static void main(String[] args)
    {
        Coin coin = Coin.quarter;

        System.out.println(coin.getValue());
    }

}

　　定义枚举类型时本质上就是在定义一个类别，只不过很多细节由编译器帮您完成，所以某种程度上，enum关键字的作用就像是class或interface。

　　当您使用“enum”定义枚举类型时，实质上您定义出来的类型继承自java.lang.Enum类型，而每个枚举的成员其实就是您定义的枚举类型的一个实例（Instance），它们都被预设为final，所以您无法改变它们，它们也是static成员，所以您可以通过类型名称直接使用它们，当然最重要的，它们都是公开的（public）。即枚举中的每个成员默认都是public static final的。

　　枚举的本质：

　　每个枚举的成员其实就是您定义的枚举类型的一个实例（Instance）。

　　当定义了一个枚举类型后，在编译的时候就能够确定该枚举类型有多少个实例，这些对象的名字是什么。在运行期间无法再使用该枚举类型创建新的实例。

枚举的比较

　　写下面一个程序：

public class ShowEnum
{
    public static void main(String[] args)
    {
        enumCompareTo(OpConstant.valueOf(args[0]));
    }
    public static void enumCompareTo(OpConstant constant)
    {
        System.out.println(constant);

        //当前输入参数跟每一个枚举中的类型比较，并输出比较结果
        for(OpConstant c : OpConstant.values())
        {
            System.out.println(constant.compareTo(c));
        }
    }

}

　　然后在Run Configurations里面传入参数SHOOT，输出如下：

　　SHOOT

　　2

　　1

　　0

　　如果传入参数TURN_RIGHT:

　　TURN_RIGHT

　　1

　　0

　　-1

这个程序用于比较枚举成员谁在前谁在后，当输入SHOOT时，SHOOT和每个值比较时，它在TURN_LEFT后面两位，在TURN_RIGHT后面一位，和自己比较输出为0。

枚举显示

　　例子：

public class ShowEnum2
{

    public static void main(String[] args)
    {
        for(OpConstant c: OpConstant.values())
        {
            System.out.printf("%d, %s, %n", c.ordinal(), c);
        }
    }
}

　　输出：

　　0, TURN_LEFT,

　　1, TURN_RIGHT,

　　2, SHOOT,

EnumSet

　　EnumSet的名称说明了其作用，它是在J2SE 5.0后加入的新类别，可以协助您建立枚举值的集合，它提供了一系列的静态方法，可以让您指定不同的集合建立方式。

　　EnumSet有多重重载的of()方法，用于构造含有指定枚举对象的枚举集合。

　　与之对应的有complementOf()方法，返回某个枚举集合的补集。

　　noneOf()方法构造一个指定枚举类型的空枚举集合。之后可以用add()方法加入元素。

　　copyOf()方法有两种重载形式，一种形式的参数为枚举集合EnumSet，另一种方式的参数为Collection。说明可以利用集合来构造枚举集合，注意如果Collection中有重复元素，只有一个会被加入枚举集合。

　　下面的代码例子中使用了这些方法：

import java.util.List;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.Iterator;

enum FontConstant
{
    Plain, Bold, Italic, Hello,
}

public class EnumSetDemo
{

    public static void main(String[] args)
    {
        System.out.println("--------------of()-----------------");
        // of()方法，构造含有指定元素的枚举集合
        EnumSet<FontConstant> enumSet = EnumSet.of(FontConstant.Plain,
                FontConstant.Bold);
        showEnumSet(enumSet);

        System.out.println("------------complementOf()---------------");
        // complementOf()方法，构造指定枚举集合的补集
        showEnumSet(EnumSet.complementOf(enumSet));

        System.out.println("--------------noneOf()-----------------");
        // noneOf()方法构造一个指定枚举类型的空枚举集合
        EnumSet<FontConstant> enumSet2 = EnumSet.noneOf(FontConstant.class);
        enumSet2.add(FontConstant.Italic);
        showEnumSet(enumSet2);

        System.out.println("---------------copyOf()------------------");
        // copyOf()方法的一种重载可以由集合构造枚举集合

        // 先构造一个List
        List<FontConstant> list = new ArrayList<FontConstant>();
        list.add(FontConstant.Bold);
        list.add(FontConstant.Italic);
        list.add(FontConstant.Plain);
        list.add(FontConstant.Bold);

        // 然后使用copyO方法构造一个EnumSet
        showEnumSet(EnumSet.copyOf(list));

    }

    public static void showEnumSet(EnumSet<FontConstant> enumSet)
    {
        for (Iterator<FontConstant> iter = enumSet.iterator(); iter.hasNext();)
        {
            System.out.println(iter.next());
        }
    }

}

EnumMap

　　EnumMap的声明是：Class EnumMap<K extends Enum<K>,V>，表明其中的Key是枚举类型。

　　使用例子如下：

import java.util.EnumMap;
import java.util.Map;

public class EnumMapDemo
{
    public static void main(String[] args)
    {
        Map<Action, String> map = new EnumMap<Action, String>(Action.class);

        map.put(Action.TURN_LEFT, "向左转");
        map.put(Action.SHOOT, "射击");
        map.put(Action.TURN_RIGHT, "向右转");

        for (Action action : Action.values())
        {
            System.out.println(map.get(action));

        }
    }
}

enum Action
{
    TURN_LEFT, TURN_RIGHT, SHOOT,
}