读Java编程思想随笔の枚举类

　　基本enum特性

　　创建enum时，编译器会为你生成一个相关的类，这个类继承自java.lang.Enum。

enum Shrubbery{
        GROUND,CRAWLING,HANGING
}
public class EnumClass {
        public static void main(String[] args) {
                for (Shrubbery s:Shrubbery.values()){
                        System.out.println(s+" ordinal:"+s.ordinal());
                        System.out.println(s.compareTo(Shrubbery.CRAWLING)+" ");
                        System.out.println(s.equals(Shrubbery.CRAWLING)+" ");
                        System.out.println(s==Shrubbery.CRAWLING);
                        System.out.println(s.getDeclaringClass());
                        System.out.println(s.name());
                        System.out.println("--------------------------");
                }
                for (String s:"HANGING CRAWLING GROUND".split(" ")){
                        Shrubbery shrub = Enum.valueOf(Shrubbery.class,s);
                        System.out.println(shrub);
                }
        }
}
//GROUND ordinal:0
//        -1
//        false
//        false
//class com.qiqi.enums.Shrubbery
//        GROUND
//        --------------------------
//        CRAWLING ordinal:1
//        0
//        true
//        true
//class com.qiqi.enums.Shrubbery
//        CRAWLING
//        --------------------------
//        HANGING ordinal:2
//        1
//        false
//        false
//class com.qiqi.enums.Shrubbery
//        HANGING
//        --------------------------
//        HANGING
//        CRAWLING
//        GROUND

　　ordinal()方法返回一个int值，这是每个enum实例在声明时的次序，从0开始。可以使用==来比较enum实例，编译器会自动为你供equals()和hashcode()方法。Enum类实现了Comparable接口，所以它具有compareTo()方法。同时，它还实现了Serializable接口。如果在enum实例上调用getDeclaringClass方法，我们就知道其所属的enum类。name()方法返回enum实例声明的名字，这与使用toString()方法效果相同。valueOf()是在Enum中定义的static方法，它根据给定的名字返回相应的enum实例，如果不存在给定名字的实例，将会抛出异常。

　　静态导入enum

import static com.qiqi.enums.Spiciness.*;//静态导入枚举类
/**
* @ClassName: Burrito
* @Description: 静态导入枚举类
* @Author huhailang
* @Date 2015/12/22 19:58
* @Company 中国奇奇科技有限公司
*/
public class Burrito {
        Spiciness degree;
        public Burrito(Spiciness degree){
                this.degree=degree;
        }

        @Override
        public String toString() {
                return "Burrito is "+degree;
        }

        public static void main(String[] args) {
                System.out.println(new Burrito(NOT));
                System.out.println(new Burrito(MEDIUM));
                System.out.println(new Burrito(FLAMING));
        }
}
//        Burrito is NOT
//        Burrito is MEDIUM
//     

　　向enum中添加新方法

public enum OzWitch {
        WEST("miss west"),
        NORTH("mis north"),
        EAST("miss east"),
        SOUTH("miss south");
        private String description;
        private OzWitch(String description){
                this.description=description;
        }
        public String getDescription(){
                return description;
        }

        public static void main(String[] args) {
                for (OzWitch witch:OzWitch.values()){
                        System.out.println(witch+":"+witch.getDescription());
                }
        }
}
//        WEST:miss west
//        NORTH:mis north
//        EAST:miss east
//        SOUTH:miss south

　　注意，如果你打算定义自己的方法，那么必须在enum实例序列的最后添加一个分号。同时，Java要求你必须先定义enum实例。如果在定义enum实例之前定义了任何方法或属性，那么在编译时就会得到错误信息。

　　enum中的构造器与方法和普通的类没有区别，因为除了少许限制之外，enum就是一个普通的类。

　　覆盖enum的方法

public enum SpaceShip {
        SCOUT,CARGO,TRANSPORT;

        @Override
        public String toString() {
                String id = name();
                String lower = id.substring(1).toLowerCase();
                return id.charAt(0)+lower;
        }
        public static void main(String[] args) {
             for (SpaceShip s:values()){
                     System.out.println(s);
             }
        }
}
//        Scout
//        Cargo
//        Transport

　　覆盖enum方法与覆盖普通类方法没有区别。

　　switch语句中的enum

enum Signal{
        GREEN,YELLOW,RED
}
public class TrafficLight {
        Signal color = Signal.RED;
        public void change(){
                /**一般情况下，我们必须使用enum类型来修饰一个enum实例，但是case语句中却不必如此*/
                switch (color){
                        case RED: color = Signal.GREEN;
                                break;
                        case GREEN:color = Signal.YELLOW;
                                break;
                        case YELLOW:color = Signal.RED;
                                break;
                }
        }
        @Override
        public String toString() {
                return "The traffic light is "+color;
        }

        public static void main(String[] args) {
                TrafficLight t = new TrafficLight();
                for (int i=0;i<7;i++){
                        System.out.println(t);
                        t.change();
                }
        }
}

　　编译器并没有抱怨switch中没有default语句，但这并不是因为每一个Signal都有对应的case语句。如果你注释掉其中的某个case语句，编译器同样不会抱怨什么。这意味着，你必须确保自己覆盖了所有的分支。但是如果在case语句中调用return，那么编译器就会抱怨缺少default语句了。

　　探讨values()

enum Explore{
        HERE,THREE
}
public class Reflection {
        public static Set<String> analyze(Class<?> enumClass){
                System.out.println("Interfaces:");
                for (Type t:enumClass.getGenericInterfaces()){
                        System.out.println(t);
                }
                System.out.println("Base:"+enumClass.getSuperclass());
                System.out.println("Methods:");
                Set<String> methods = new TreeSet<String>();
                for (Method m:enumClass.getMethods()){
                        methods.add(m.getName());
                }
                System.out.println(methods);
                return methods;
        }

        public static void main(String[] args) {
                Set<String> exploreMethods = analyze(Explore.class);
                Set<String> enumMethods = analyze(Enum.class);
                System.out.println(exploreMethods.containsAll(enumMethods));
                System.out.println("Explore.removeAll(Enum):");
                exploreMethods.removeAll(enumMethods);
                System.out.println(exploreMethods);
                //OSExecute.command("javap Explore");
        }
}
//        Interfaces:
//        Base:class java.lang.Enum
//        Methods:
//        [compareTo, equals, getClass, getDeclaringClass, hashCode, name, notify, notifyAll, ordinal, toString, valueOf, values, wait]
//        Interfaces:
//        java.lang.Comparable<E>
//        interface java.io.Serializable
//        Base:class java.lang.Object
//        Methods:
//        [compareTo, equals, getClass, getDeclaringClass, hashCode, name, notify, notifyAll, ordinal, toString, valueOf, wait]
//        true
//        Explore.removeAll(Enum):
//        [values]

　　我们知道，编译器为你创建的enum类都继承自Enum类。然而，如果你研究一下Enum类就会发现，它并没有values()方法。答案是values()方法是由编译器添加的static方法。可以看出，在创建Explore的过程中，编译器还为其添加了valueOf()方法。这可能有点迷惑，Enum类不是已经有valueOf()方法了吗。不过Enum中valueOf()方法需要两个参数，而这个新增的方法只需一个参数。

enum Search{
        HITHER,YON
}
public class UpcastEnum {
        public static void main(String[] args) {
                Search [] vals = Search.values();
                Enum e = Search.HITHER;
                /**Enum通过getEnumConstants()取得enum实例*/
                for (Enum en:e.getClass().getEnumConstants()){
                        System.out.println(en);
                }
        }
}
//        HITHER
//        YON

　　enum实例实现多个接口

enum CartoonCharacter implements Generator<CartoonCharacter>{
        SLAPPY,SPANKY,PUNCHY,SILLY,BOUNCY,NUTTY,BOB;
        private Random rand = new Random(47);
        @Override
        public CartoonCharacter next() {
                return values()[rand.nextInt(values().length)];
        }
}
public class EnumImplementation {
        public static <T> void printNext(Generator<T> rg){
                System.out.println(rg.next()+",");
        }

        public static void main(String[] args) {
                CartoonCharacter cc = CartoonCharacter.BOB;
                for (int i=0;i<10;i++){
                        printNext(cc);
                }
        }
}

　　我们已经知道，所有enum都继承自java.lang.Enum类。由于Java不支持多重继承，所以enum不能继承其他类然而，在我们创建一个新的enum时，我们可以同时实现一个或多个接口。

　　随机选取

public class Enums {
    private static Random rand = new Random(47);
    public static <T extends Enum<T>> T random(Class<T> ec) {
        return random(ec.getEnumConstants());
    }
    public static <T> T random(T[] values) {
        return values[rand.nextInt(values.length)];
    }
} ///:~

　　古怪的语法<T extends Enum<T>> 表示T是一个enum实例。而将Class<T>作为参数的话，我们就可以利用Class对象得到enum实例的数组了。重载后的random()方法只需使用T[]作为参数，因为它并不会调用Enum上的任何操作，它只需从数组中随机选择一个元素即可。这样，最终的返回类型正式enum类型。

　　Enum只是一个相当短小的类，但是你会发现，它能消除很多冗余的代码。

enum Activity{
    SITTING,LYING,STANDING,HOPPING,RUNNING,DODGING,JUMPING,FALLING,FLYING
}
public class RandomTest {
    public static void main(String[] args) {
        for (int i=0;i<20;i++){
            System.out.println(Enums.random(Activity.class)+" ");
        }
    }
}
//        STANDING
//        FLYING
//        RUNNING
//        STANDING
//        RUNNING
//        STANDING
//        LYING
//        DODGING
//        SITTING
//        RUNNING
//        HOPPING
//        HOPPING
//        HOPPING
//        RUNNING
//        STANDING
//        LYING
//        FALLING
//        RUNNING
//        FLYING
//        LYING