《Thinking in Java》学习——19章枚举类型

基本enum特性

1.创建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.print(s.compareTo(Shrubbery.CRAWLING) + " ");
            System.out.print(s.equals(Shrubbery.CRAWLING) + " ");
            System.out.print(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);
        }
    }
}
/*
Output:
GROUND ordinal: 0
-1 false false
class Shrubbery
GROUND
----------------------
CRAWLING ordinal: 1
0 true true
class Shrubbery
CRAWLING
----------------------
HANGING ordinal: 2
1 false false
class Shrubbery
HANGING
----------------------
HANGING
CRAWLING
GROUND
*/

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

一.将静态导入用于enum

1.使用static import能够将enum实例等标识符带入当前的命名空间，所以无需再用enum类型来修饰enum实例。

向enum中添加新方法

1.除了不能继承自一个enum之外，我们基本上可以将enum看作一个常规的类。也就是说我们可以向enum中添加方法，且enum中的构造器和方法和普通的类没有任何区别。
2.注意，如果你打算定义自己的方法，那么必须在enum实例序列的最后添加一个分号。同时Java要求你必须先定义enum实例。
3.即使不声明为private，我们只能在enum定义内部使用其构造器创建enum实例。

一.覆盖enum的方法

1.这里我们覆盖了toString()方法，给我们提供了另一种方式来为枚举实例生成不同的字符串描述信息：

public enum SpaceShip {
    SOCUT, CARGO, TRANSPORT, CRUISER, BATTLESHIP, MOTHERSHIP;
    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);
        }
    }
}
/*
SOCUT
CARGO
TRANSPORT
CRUISER
BATTLESHIP
MOTHERSHIP
*/

switch语句中的enum

1.在switch中使用enum，是enum提供的一项非常便利的功能。枚举实例天生就具备整数值的次序，并且可以通过ordinal()方法取得其次序。

values()的神秘之处

1.编译器为你创建的enum类都继承自Enum类。然而，Enum类中并没有values()方法。事实上，values()是由编译器添加的static方法。
2.由于values()方法是由编译器插入到enum定义中的static方法，所以，如果你将enum实例向上转型为Enum，那么values()方法就不可访问了。不过，在Class中有一个getEnumConstants()方法，所以即便Enum接口中没有values()方法，我们仍可以通过Class对象取得所有的enum实例：

enum Search { HITHER, YON }

public class UpcastEnum {
    public static void main(String... args) {
        Search[] vans = Search.values();
        Enum e = Search.HITHER;
        for (Enum en : e.getClass()) {
            System.out.println(en);
        }
    }
}
/*
Output:
HITHER
YON
*/

不过需要注意的是，对布什枚举的类调用该方法时。会返回null。

实现，而非继承

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

随机选取

1.有时我们需要从enum中进行随机选择，我们可以利用泛型，从而使得这个工作更一般化：

public class Enums {
    public static Random rand = new Random(47);
    public static > T random(Class ec) {
        return random(ec.getEnumConstants());
    }
    public static  T random(T[] values) {
        return values[rand.nextInt(values.length)];
    }
}

使用接口组织枚举

1.在一个接口内部，创建实现该接口的枚举，以此将元素进行分组，可以达到将枚举元素分类组织的目的：

public interface Food {
    enum Appetizer implements Food {
        SALAD, SOUP, SPRING_ROLLS;
    }
    enum MainCourse implements Food {
        LASAGNE, BURRITO, PAD_THAI, 
        LENTILS, HUMMOUS, VINDALOO;
    }
    enum Dessert implements Food {
        TIRAMISU, GELATO, BLACK_FOREST_CAKE,
        FRUIT, CREME_CARAMEL;
    }
    enum Coffee implements Food {
        BLACK_COFFEE, DECAF_COFFEE, ESPRESSO, 
        LATTE, CAPPUCCINO, TEA, HERB_TEA;
    }
}

2.如果想创建一个“枚举的枚举”，那么可以创建一个新的enum，然后用其实例包装Food中的每一个enum类：

public enum Course {
    APPETIZER(Food.Appetizer.class);
    MAINCOURSE(Food.MainCourse.class);
    DESSERT(Food.Dessert.class);
    COFFEE(Food.Coffee.class);
    private Food[] values;
    private Course(Class kind) {
        values = kind.getEnumConstants();
    }
    public Food randomSelection() {
        return Enums.random(values);
    }
}

使用EnumSet替代标志

1.EnumSet的设计充分考虑到了速度因素。就其内部而言，它可能就是将一个long值作为比特向量，所以EnumSet非常快速高效。使用EnumSet的优点是，它在说明一个二进制位是否存在时，具有更好的表达能力并且无需担心性能。
2.使用各种重载方法EnumSet.of()，可以将一个enum转换为一个Set方法。

使用EnumMap

1.EnumMap是一种特殊的Map，它要求其中的键必须来自于一个enum。由于enum本身的限制，所以EnumMap在内部可由数组实现。因此EnumMap的速度很快，我们可以放心地使用enum实例在EnumMap中进行查找操作。不过，我们只能将enum的实例作为键来调用put()方法，其他操作与使用一般的Map差不多。
2.与EnumSet一样，enum实例定义时的次序决定了其在EnumMap中的顺序。

常量相关的方法

1.要实现常量相关的方法，你需要为enum定义一个或多个abstract方法，然后为每个enum实例实现抽象方法：

public enum ConstantSpecificMethod {
    DATE_TIME {
        String getInfo() {
            return DateFormat.getDateInstance().format(new Date());
        },
        CLASSPATH {
            String getInfo() {
                return System.getenv("CLASSPATH");
            }
        }
        VERSION {
            String getInfo() {
                return System.getProperty("java.version");
            }
        }
        abstract String getInfo();
        public static void main(String... args) {
            for (ConstantSpecificMethod csm : values()) {
                System.out.println(csm.getInfo());
            }
        }
    }
}

2.编译器不允许我们将一个enum实例当作class类型，因为每一个enum元素都是一个Enum类型的static final实例。同时，由于它们是static实例，无法访问外部类的非static元素或方法，素以对于内部的enum的实例而言，其行为与一般的内部类并不相同。