枚举类型

enum 关键字用于创建一个新类型，其中包含一组数量有限的命名变量，并视这些变量为常规程序组件。

枚举类型的基本特性

之前已经见过可以调用枚举类型中的 values() 方法遍历枚举常量列表。values() 方法生成一个由枚举常量组成的数组，其中常量的顺序和常量声明的顺序保持一致，这样就可以方便地（比如通过for-in循环）使用结果数组了。

当创建枚举类型时，编译器会生成一个辅助类，这个类自动继承自 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.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);
        }
    }
}
/* 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() 方法返回一个从 0 开始的 int 值，代表每个枚举实例的声明顺序。可以使用 == 来比较枚举实例（equals() 和 hashCode() 方法会由编译器自动生成） Enum 类实现了 Comparable 接口（因此可比较)，所以自动包含了 compareTo() 方法，另外它还实现了 Serializable 接口（因此可序列化）。

调用枚举实例的 getDeclaringClass() 方法会得到该枚举实例所属的外部包装类。

name() 方法返回枚举实例被声明的名称，使用 toString() 同样也可以返回该名称。 valueOf() 方法是 Enum 类中的静态方法，它根据传入的 String，返回名称与该 String 匹配的枚举实例。如果匹配的实例不存在，则抛出异常。

静态导入枚举类型

package Burrito;

public enum SpicinessEnum {
    NOT, MILD, MEDIUM, HOT, FLAMING
}

package Burrito;

import static Burrito.SpicinessEnum.*;

public class Burrito2 {
    SpicinessEnum degree;
    public Burrito2(SpicinessEnum degree) {
        this.degree = degree;
    }
    @Override public String toString() {
        return "Burrito is " + degree;
    }

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

static import 将所有的枚举实例标识符都引人了本地命名空间，这样不需要显式地使用枚举类型来限定。相较于显式地用枚举类型来限定枚举实例，两种方式要根据具体情况评估使用。

注意，如果枚举定义在同一个文件中，或者定义在默认包中，则无法使用该方式。

在枚举类型中增加自定义方法

除了无法被继承外，枚举类型基本可以看作一个普通的类。即可以在里面增加自定义方法，甚至增加一个 main() 方法。

默认的 toString() 方法只会返回枚举实例的名称，而你很可能想为枚举实例生成不同于该默认方式的描述。为此，可以实现一个构造方法，以获取额外的信息，然后再用额外的方法来提供扩展描述，如下例所示：

public enum OzWitch {
    // 实例必须在方法前定义
    WEST("Miss Gulch, aka the Wicked Witch of the West"),
    NORTH("Glinda, the Good Witch of the North"),
    EAST("Wicked Witch of the East, wearer of the Ruby " +
            "Slippers, crushed by Dorothy's house"),
    SOUTH("Good by inference, but missing");
    private String description;
    // 构造器访问权限必须是包访问或者 private
    private OzWitch(String description) {
        this.description = description;
    }
    public String getDescription() { return description;}

    public static void main(String[] args) {
        for(OzWitch width : OzWitch.values())
            System.out.println(width + ": " + width.description);
    }
}
/* output
WEST: Miss Gulch, aka the Wicked Witch of the West
NORTH: Glinda, the Good Witch of the North
EAST: Wicked Witch of the East, wearer of the Ruby Slippers, crushed by Dorothy's house
SOUTH: Good by inference, but missing */

如果你想增加自定义方法，则必须先用分号结束枚举实例的序列。同时，Java 会强制你在枚举中先定义实例。如果在定义实例之前定义了任何方法或字段，则会抛出编译时错误。

除了少量特殊限制外，枚举类型的构造器和方法的写法和普通类一样。

虽然本例中的构造方法是私有的，但使用哪种访问权限实际上区别并不大：构造方法只能用来创建你在枚举定义中声明的枚举实例，在枚举定义完成后，编译器不会允许你用它来创建任何新的类型。

重载方法

还可以重载 toString() 方法来为枚举生成不同的 String 值。重载 enum 的 toString() 方法和重载任何普通类的方法相同：

public enum SpaceShip {
    SCOUT, CARGO, TRANSPORT,
    CRUISER, BATTLESHIP, MOTHERSHIP;
    @Override public String toString() {
        String id = name();
        String lower = id.substring(1).toLowerCase();
        return id.charAt(0) + lower;
    }

    public static void main(String[] args) {
        Stream.of(values())
                .forEach(System.out::println);
    }
}
/* output
Scout Cargo Transport Cruiser Battleship Mothership */

toString() 方法通过调用 name() 方法获取 SpaceShip 的名称，并且修改了结果，使得结果中的英文单词仅首字母为大写。

在 switch 语句中使用枚举

这是枚举的一个非常方便的功能。通常，switch 语句只能使用整型或字符串类型的值，但是由于 enum 内部已经构建了一个整型序列，并且可以通过 ordinal() 方法来得到枚举实例的顺序（编译器做了相应的工作)，所以枚举类型可以用在 switch 语句中。

通常要使用枚举实例必须用枚举的类型名来限定，但在 case 语句中不需要。下面是一个状态机示例：

enum Signal { GREEN, YELLOW, RED, }
public class TrafficLight {
    Signal color = Signal.RED;
    public void change() {
        switch (color) {
            case RED -> color = Signal.GREEN;
            case GREEN -> color = Signal.YELLOW;
            case YELLOW -> color = Signal.RED;
        }
    }
    @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 < 4; i++) {
            System.out.println(t);
            t.change();
        }
    }
}
/* output
The traffic light is RED
The traffic light is GREEN
The traffic light is YELLOW
The traffic light is RED */

编译器没有因为该 switch 中没有 default 语句而报错，但这并不是因为它注意到了你为每个 Signal 实例都编写了 case 分支。即使你注释掉某个 case 分支，也仍然不会报错。这意味着你必须要小心，确保你手动投盖了所有的分支。但是，如果此时你在 case 语句中调用了 return（而且没有编写 dafault)，则编译器会报错，即使你已经覆盖到了枚举中的所有值。

values() 方法的神秘之处

所有的枚举类型都是由编译器通过继承 Enum 类来创建的。然而，如果仔细查看 Enum 类的代码，你会发现里面并没有 values() 方法，却已经能直接使用它了。可以使用反射来看一下：

enum Explore { HERE, THERE }
public class Reflection {
    public static Set<String> analyse(Class<?> enumClass) {
        System.out.println("---- Analyzing " + 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<>();
        for(Method m : enumClass.getMethods())
            methods.add(m.getName());
        System.out.println(methods);
        return methods;
    }
    public static void main(String[] args) {
        Set<String> exploreMethods = analyse(Explore.class);
        Set<String> enumMethods = analyse(Enum.class);
        System.out.println("Explore.containsAll(Enum)? " + exploreMethods.containsAll(enumMethods));
        System.out.print("Explore.removeAll(Enum): ");
        exploreMethods.removeAll(enumMethods);
        System.out.println(exploreMethods);
        OSExecute.command("javap -cp target/classes Explore");
    }
}
/* output
---- Analyzing class Explore ----
Interfaces: 
Base: class java.lang.Enum
Methods: 
[compareTo, describeConstable, equals, getClass, getDeclaringClass, hashCode, name, notify, notifyAll, ordinal, toString, valueOf, values, wait]
---- Analyzing class java.lang.Enum ----
Interfaces: 
interface java.lang.constant.Constable
java.lang.Comparable<E>
interface java.io.Serializable
Base: class java.lang.Object
Methods: 
[compareTo, describeConstable, equals, getClass, getDeclaringClass, hashCode, name, notify, notifyAll, ordinal, toString, valueOf, wait]
Explore.containsAll(Enum)? true
Explore.removeAll(Enum): [values]
Compiled from "Reflection.java"
final class Explore extends java.lang.Enum<Explore> {
  public static final Explore HERE;
  public static final Explore THERE;
  public static Explore[] values();
  public static Explore valueOf(java.lang.String);
  static {};
} */

values() 方法是由编译器添加的一个静态方法。注意，在创建 Explore 的过程中，编译器还为其添加了 valueOf() 方法。可以看到，Enum 类中本来就有 valueOf() 方法，但是该方法有两个参数，新加入的则只有一个。因为这里 Set 方法只关心方法名，不考虑方法签名，因此调用 Explore.removeAll(Enum) 后，只剩下了 [values]。

打印结果显示 Explore 枚举被编译器限定为 final 类，所以你无法继承一个枚举类。此外还有一个 static 的初始化子句，稍后会看到它可以被重定义。

由于类型擦除，反编译器得不到 Enum 类的完整信息，因此只能将 Explore 类的基类作为一个原始 Enum 类显示，而不是实际的 Enum<Explore>。

由于 values() 方法是在枚举类定义时插入的静态方法，因此如果将枚举类型向上转型为 Enum，该方法将不可用。注意，Class 类有一个 getEnumConstants() 方法，所以即使 Enum 的接口中没有 values() 方法，仍然可以通过 Class 对象得到 enum 的实例：

enum Search { HITHER, YON }
public class UpcastEnum {
    public static void main(String[] args) {
        Search[] vals = Search.values();
        Enum e = Search.HITHER;
        // e.values() // 向上转型，该方法不可用
        // 但可以通过 Class 类中方法来获得
        for(Enum en : e.getClass().getEnumConstants())
            System.out.println(en);
    }
}
/* output
HITHER
YON */

由于 getEnumConstants() 是 Class 类中的方法，对非枚举类的调用：

public class NonEnum {
    public static void main(String[] args) {
        Class<Integer> intClass = Integer.class;
        try {
            for(Object en : intClass.getEnumConstants())
                System.out.println(en);
        } catch (Exception e) {
            System.out.println("Exception: " + e);
        }
    }
}
/* output
Exception: java.lang.NullPointerException: Cannot read the array length because "<local2>" is null */

此时会返回 null，如果尝试引用结果，就会抛出异常。

实现，非继承

由于所有的 enum 对象都继承自 java.lang.Enum，因此无法通过继承方式创建一个枚举对象。

但是，可以实现一个或多个接口：

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

    public static void main(String[] args) {
        CartoonCharacter c = CartoonCharacter.NUTTY;
        for(int i = 0; i < 10; i++)
            printNext(c);
    }
}
/* output
BOB, PUNCHY, BOB, SPANKY, NUTTY, PUNCHY, SLAPPY, NUTTY, NUTTY, SLAPPY,  */

这里必须先得有一个枚举实例，才能在其上调用某个方法。由于实现了 Supplier 接口，因此此处的 CartoonCharacter 对象可以传入任何将 Supplier 对象作为参数的方法。

随机选择

由于许多示例需要从 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 是一个枚举类型实例，通过传入 Class<T>，使得这个 Class 对象变得可用，从而可以生成枚举实例的数组。重载后的 random() 方法只需使用 T[] 作为参数，因为它并不会调用 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 < 10; i++)
            System.out.print(Enums.random(Activity.class) + " ");
    }
}
/* output
STANDING FLYING RUNNING STANDING RUNNING STANDING LYING DODGING SITTING RUNNING */

使用接口组织枚举

枚举类型无法被继承，这一点可能有时会让人沮丧。想要继承枚举的动机，一部分源自希望扩充原始枚举中的元素，另一部分源自想要使用子类型来创建不同的子分组。

可以在一个接口内对元素进行分组，然后基于这个接口生成枚举，通过这样的方式来实现元素的分类。假如有一些类型互不相同的 Food，想创建若干 enum 组织它们，但又希望它们仍然是 Food 类型：

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;
    }
}

实现接口是唯一可子类化枚举的方式，因此所有嵌套在 Food 中的枚举类型都实现了 Food 接口。

import static menu.Food.*;

public class TypeOfFood {
    public static void main(String[] args) {
        Food food = Appetizer.SOUP;
        food = MainCourse.HUMMOUS;
        food = Dessert.GELATO;
    }
}

对于每个实现了 Food 接口的枚举类型，都可以向上转型为 Food，因此它们全都是 Food 类型。

如果要创建“由枚举组成的枚举”，可以为 Food 中每个枚举类型都创建一个外部枚举类型：

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<? extends Food> kind) {
        values = kind.getEnumConstants();
    }
    public Food randomSelection() {
        return Enums.random(values);
    }
}

这里，每个枚举类型都接收相应的 Class 对象以作为构造参数，从而可以使用 getEnumConstants() 来提取出所有的枚举实例并存储起来，这些实例稍后会在 randomSelection() 中被用到。现在可以从每个 Course（菜项）中选择一种 Food，生成一份随机菜单了：

public class Meal {
    public static void main(String[] args) {
        for(int i = 0; i < 2; i++) {
            for(Course course : Course.values()) {
                Food food = course.randomSelection();
                System.out.println(food);
            }
            System.out.println("******");
        }
    }
}
/* output
SPRING_ROLLS
VINDALOO
FRUIT
DECAF_COFFEE
******
SOUP
VINDALOO
FRUIT
TEA
****** */

此外，创建一个由枚举类型组成的枚举类型的意义在于，可以方便地遍历每个 Course。之后的例子 VendingMachine.java 中，是另一种由不同约束条件指定的分类方法。

另一种更简洁的分类方法是在枚举内嵌套枚举：

enum SecurityCategory {
    STOCK(Security.Stock.class),
    BOND(Security.Bond.class);
    Security[] values;
    SecurityCategory(Class<? extends Security> kind) {
        values = kind.getEnumConstants();
    }
    interface Security {
        enum Stock implements Security {
            SHORT, LONG, MARGIN
        }
        enum Bond implements Security {
            MUNICIPAL, JUNK
        }
    }
    public Security randomSelection() {
        return Enums.random(values);
    }

    public static void main(String[] args) {
        for(int i = 0; i < 4; i++) {
            SecurityCategory category = Enums.random(SecurityCategory.class);
            System.out.println(category + ": " + category.randomSelection());
        }
    }
}

Security 接口用于将内部的枚举类型作为公共类型聚合到一起，然后再将它们归类到 SecurityCategory 中的枚举中。

可以将该方法应用到 Food 示例中：

public enum Meal2 {
    APPETIZER(Food.Appetizer.class),
    MAINCOURSE(Food.MainCourse.class),
    DESSERT(Food.Dessert.class),
    COFFEE(Food.Coffee.class);
    private Food[] values;
    Meal2(Class<? extends Food> kind) {
        values = kind.getEnumConstants();
    }
    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;
        }
    }
    public Food randomSelection() {
        return Enums.random(values);
    }

    public static void main(String[] args) {
        for(int i = 0; i < 2; i++) {
            for(Meal2 meal : Meal2.values()) {
                Food food = meal.randomSelection();
                System.out.println(food);
            }
            System.out.println("******");
        }
    }
}

这样只是重新组织了下代码，但在一些情况下，可以使结构更清晰。

用 EnumSet 来代替标识

Set 是一种不允许有重复元素存在的集合。enum 要求每个内部成员都是唯一的，看起来很像 Set，但是由于无法添加或移除元素，它井不如 Set 那么好用。于是 Enumset 被引入，用来配合 enum 的使用，以替代传统的基于 int 的“位标识”用法。这种标识可以用来表示某种“开/关”信息，不过，使用这种标志，最终操作的是各种位状态，而不是想要表达的概念，因此很容易写出令人难以理解的代码。

性能是 EnumSet 的设计目标之一，因为需要与高效的位标识竞争（位操作性能远高于 HashSet）。它的内部实现是用一个 long 型的位向量表示集合中的元素，所以非常高效。这样做的优点是，说明一个二进制位是否存在时，具有更好的表达能力，并且无需担心性能。

EnumSet 中的元素必须来自某个枚举类型。下面的例子，使用枚举来表示大楼中警报感应器的安装位置：

package alarm
public enum AlarmPoints {
    STAIR1, STAIR2, LOBBY, OFFICE1, OFFICE2, OFFICE3,
    OFFICE4, BATHROOM, UTILITY, KITCHEN
}

然后使用 EnumSet 跟踪报警的状态：

package alarm
public class EnumSets {
    public static void main(String[] args) {
        EnumSet<AlarmPoints> points =
              EnumSet.noneOf(AlarmPoints.class);
        points.add(BATHROOM);
        System.out.println(points);
        points.addAll(EnumSet.of(STAIR1, STAIR2, KITCHEN));
        System.out.println(points);
        points = EnumSet.allOf(AlarmPoints.class);
        points.removeAll(EnumSet.of(STAIR1, STAIR2, KITCHEN));
        System.out.println(points);
        points.removeAll(EnumSet.range(OFFICE1, OFFICE4));
        System.out.println(points);
        points = EnumSet.complementOf(points);
        System.out.println(points);
    }
}
/* output
[BATHROOM]
[STAIR1, STAIR2, BATHROOM, KITCHEN]
[LOBBY, OFFICE1, OFFICE2, OFFICE3, OFFICE4, BATHROOM, UTILITY]
[LOBBY, BATHROOM, UTILITY]
[STAIR1, STAIR2, OFFICE1, OFFICE2, OFFICE3, OFFICE4, KITCHEN] */

EnumSet 的方法名都相当直观，可以查阅 JDK 文档找到其完整详细的描述。查看文档，会发现 of() 方法被重载了多次，不但为可变数量参数进行了重载，而且为接收 2 至 5 个显式的参数的情况都进行了重载，体现出了 EnumSet 对性能的关注。其实只使用单独的 of() 方法解决可变参数已经可以解决整个问题了，但是对比显式的参数，会有一点性能损失。采用现在这种设计，当只使用 2 到 5 个参数调用 of() 方法时，可以调用对应的重载过的方法（速度稍快一点），而当使用一个参数或多过 5 个参数时，你调用的将是使用可变参数的 of() 方法。注意，如果你只使用一个参数，编译器并不会构造可变参数的数组，所以与调用只有一个参数的方法相比，也就不会有额外的性能损耗。

EnumSet 是基于 64 位的 long 构建的，每个枚举实例需要占用 1 位来表达是否存在的状态，这意味着在单个 long 的支撑范围内，1个 EnumSet 最多可支持包含 64 个元素的枚举类型。如果枚举中元素超过 64 个：

public class BigEnumSet {
    enum Big { A0, A1, A2, A3, A4, A5, A6, A7, A8, A9,
        A10, A11, A12, A13, A14, A15, A16, A17, A18, A19,
        A20, A21, A22, A23, A24, A25, A26, A27, A28, A29,
        A30, A31, A32, A33, A34, A35, A36, A37, A38, A39,
        A40, A41, A42, A43, A44, A45, A46, A47, A48, A49,
        A50, A51, A52, A53, A54, A55, A56, A57, A58, A59,
        A60, A61, A62, A63, A64, A65, A66, A67, A68, A69,
        A70, A71, A72, A73, A74, A75 }

    public static void main(String[] args) {
        EnumSet<Big> bigEnumSet = EnumSet.allOf(Big.class);
        System.out.println(bigEnumSet);
    }
}
/* output
[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64, A65, A66, A67, A68, A69, A70, A71, A72, A73, A74, A75] */

显然 EnumSet 支持超过 64 个元素的枚举类型，所以可以推测，它在必要时会引入新的 long 型变量。

使用 EnumMap

EnumMap 是一种特殊的 Map，它要求其中的键（key）必须来自一个 enum，由于 enum 本身的限制，所以 EnumMap 在内部可由数组实现。因此 EnumMap 的性能很好，可以放心地使用 enum 实例在 EnumMap 中进行查找操作。

只能用 enum 的实例作为键来调用 put() 方法，其他操作与使用一般的 Map 差不多。

下面的例子演示了设计模式中的命令模式。这种模式由一个(通常）只包含一个方法的接口开始，然后为该方法创建多个具有不同行为的实现。只需要配置好这些命令对象，程序就会根据需要来调用它们:

interface Command { void action();}

public class EnumMaps {
    public static void main(String[] args) {
        EnumMap<AlarmPoints, Command> em = new EnumMap<>(AlarmPoints.class);
        em.put(KITCHEN, () -> System.out.println("Kitchen fire!"));
        em.put(BATHROOM, () -> System.out.println("Bathroom alert!"));
        for(Map.Entry<AlarmPoints, Command> e : em.entrySet()) {
            System.out.print(e.getKey() + ": ");
            e.getValue().action();
        }
        try {
            em.get(UTILITY).action(); // 若 key 没有值
        } catch (Exception e) {
            System.out.println("Exception: " + e);
        }
    }
}
/* output
BATHROOM: Bathroom alert!
KITCHEN: Kitchen fire!
Exception: java.lang.NullPointerException: Cannot invoke "alarm.Command.action()" because the return value of "java.util.EnumMap.get(Object)" is null */

和 EnumSet 一样，EnumMap 中的元素顺序由它们在枚举中定义的顺序决定。

最后部分说明，enum 的每个实例作为一个键，总是存在的。但是，如果你没有为这个键调用 put() 方法来存入相应的值的话，其对应的值就是 null。

相较于常量特定方法（constant-specific method），EnumMap 的优势是可以改变值对象，而常量特定方法在编译时是不可变的。

后面会看到，EnumMap 支持多路分发，以应对多个类型的枚举共存且相互影响的各种场景。

常量特定方法

Java 的枚举机制可以通过为每个枚举实例编写不同的方法，来赋予它们不同的行为。要实现这一点，可以在枚举类型中定义一个或多个抽象方法，然后为每个枚举实例编写不同的实现：

public enum ConstantSpecificMethod {
    DATA_TIME {
        @Override String getInfo() {
            return DateFormat.getDateInstance()
                    .format(new Date());
        }
    },
    CLASSPATH {
        @Override String getInfo() {
            return System.getenv("CLASSPATH");
        }
    },
    VERSION {
        @Override 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());
    }
}
/* output
2024年4月20日
null
21 */

可以通过关联的枚举实例来查找和调用方法。这通常叫做表驱动模式（注意，和前面的命令模式很像）。

在面向对象编程中，不同的行为和不同的类相关联。通过常量特定方法，枚举类型的各种实例可以拥有各自的行为，这表明每个实例都是不同的类型。在上面的例子中，每个枚举实例都被视同于“基类” ConstantSpecificMethod 的实例，但调用 getInfo() 方法时的行为是多态的。

然而，enum 实例与类的相似之处也仅限于此了。我们并不能真的将 enum 实例作为一个类来使用：

enum LikeClasses {
    WINKEN {
      @Override void behavior() {
          System.out.println("Behavior 1");
      }
    },
    BLINKEN {
        @Override void behavior() {
            System.out.println("Behavior 2");
        }
    },
    NOD {
        @Override void behavior() {
            System.out.println("Behavior 3");
        }
    };
    abstract void behavior();
}
public class NotClasses {
    // void f1(LikeClasses.WINKEN instance) {} // 不行
}
// javap -c LikeClasses

编译器不允许将枚举实例作为类类型来使用，通过分析编译器生成代码，就明白了：每个枚举元素都是 LikeClasses 的一个 static final 的实例。

同时，由于它们是 static 实例，无法访问外部类的非 static 元素或方法，所以对于内部的 enum 的实例而言，其行为与一般的内部类并不相同。

下面是洗车的例子，每个用户拿到一个洗车选项的菜单，每个选项代表不同的操作，每个选项都可以分配一个常量特定方法，然后用一个 EnumSet 来持有用户的选择：

public class CarWash {
    public enum Cycle {
        UNDERBODY {
            @Override void action() {
                System.out.println("Spraying the underbody");
            }
        },
        WHEELWASH {
            @Override void action() {
                System.out.println("Washing the wheels");
            }
        },
        PREWASH {
            @Override void action() {
                System.out.println("Loosening the dirt");
            }
        },
        BASIC {
            @Override void action() {
                System.out.println("The basic wash");
            }
        },
        HOTWAX {
            @Override void action() {
                System.out.println("Applying hot wax");
            }
        },
        RINSE {
            @Override void action() {
                System.out.println("Rinsing");
            }
        },
        BLOWDRY {
            @Override void action() {
                System.out.println("Blowing dry");
            }
        };
        abstract void action();
    }
    EnumSet<Cycle> cycles = EnumSet.of(Cycle.BASIC, Cycle.RINSE);
    public void add(Cycle cycle) {
        cycles.add(cycle);
    }
    public void washCar() {
        for(Cycle cycle : cycles)
            cycle.action();
    }
    @Override public String toString() {
        return cycles.toString();
    }

    public static void main(String[] args) {
        CarWash wash = new CarWash();
        System.out.println(wash);
        wash.washCar();
        // 添加顺序不影响实际顺序
        wash.add(Cycle.BLOWDRY);
        wash.add(Cycle.BLOWDRY); // 重复添加会忽略
        wash.add(Cycle.RINSE);
        wash.add(Cycle.UNDERBODY);
        System.out.println(wash);
        wash.washCar();
    }
}
/* output
[BASIC, RINSE]
The basic wash
Rinsing
[UNDERBODY, BASIC, RINSE, BLOWDRY]
Spraying the underbody
The basic wash
Rinsing
Blowing dry */

定义常量特定方法的语法与定义匿名内部类相似，但更简洁。

由于 EnumSet 是一种 Set，因此对同一个洗车选项，只能出现一次。而且输出的顺序与添加顺序无关，而是定义时的顺序。

除了实现 abstract 方法以外，是否可以重写常量特定方法：

public enum OverrideConstantSpecific {
    NUT, BOLT,
    WASHER {
        @Override void f() {
            System.out.println("Overridden method");
        }
    };
    void f() {
        System.out.println("default behavior");
    }

    public static void main(String[] args) {
        for(OverrideConstantSpecific ocs : values()) {
            System.out.print(ocs + ": ");
            ocs.f();
        }
    }
}
/* output
NUT: default behavior
BOLT: default behavior
WASHER: Overridden method */

虽然 enum 有某些限制，但是一般而言，还是可以将其看作是类来实验。

用枚举实现职责链模式

职责链（Chain of Responsibility）设计模式先创建一批用于解决目标问题的不同方法，然后将它们连成一条“链”。当一个请求到来时，它遍历这个链，直到链中的某个解决方案能够处理该请求。

用常量特定方法可以实现一条简单的职责链，考虑一个邮局模型，它对每一封邮件都会尝试用最常见的方式来处理，（如果行不通）并不断尝试别的方式，直到该邮件最终被视为“死信”（无法投递)。每种尝试都可以看作一个策略（另一种设计模式），而整个策略列表放在一起就是一条职贵链。

先来描述一下邮件。邮件的每个关键特征都可以用 enum 来表示。程序将随机地生成 Mail 对象，如果要减小一封邮件的 GeneralDelivery 为 YES 的概率，那最简单的方法就是多创建几个非 YES 的 enum 实例，所以 enum 的定义看起来有点古怪。

Mail 中有一个 randomMail() 方法，它负责随机地创建用于测试的邮件。而 generator() 方法生成一个 Iterable 对象，该对象在你调用 next() 方法时，在其内部使用 randomMail() 来创建 Mail 对象。该结构允许通过调用 Mail.generator() 方法实现 for-in 循环：

class Mail {
    enum GeneralDelivery { YES, NO1, NO2, NO3, NO4, NO5}
    enum Scannability { UNSCANNABLE, YES1, YES2, YES3, YES4}
    enum Readability { ILLEGIBLE, YES1, YES2, YES3, YES4}
    enum Address { INCORRECT, OK1, OK2, OK3, OK4}
    enum ReturnAddress { MISSING, OK1, OK2, OK3, OK4}
    GeneralDelivery generalDelivery;
    Scannability scannability;
    Readability readability;
    Address address;
    ReturnAddress returnAddress;
    static long count = 0;
    long id = count++;
    @Override public String toString() {
        return "Mail: " + id;
    }
    public String details() {
        return toString() + ", GeneralDelivery: " + generalDelivery
                + ", Scannability: " + scannability
                + ", Readability: " + readability
                + ", Address: " + address
                + ", ReturnAddress: " + returnAddress;
    }
    public static Mail randomMail() {
        Mail m = new Mail();
        m.generalDelivery = Enums.random(GeneralDelivery.values());
        m.scannability = Enums.random(Scannability.class);
        m.readability = Enums.random(Readability.class);
        m.returnAddress = Enums.random(ReturnAddress.class);
        m.address = Enums.random(Address.class);
        return m;
    }
    public static Iterable<Mail> generator(final int count) {
        return new Iterable<Mail>() {
            int n = count;
            @Override public Iterator<Mail> iterator() {
                return new Iterator<Mail>() {
                    @Override public boolean hasNext() {
                        return n-- > 0;
                    }

                    @Override public Mail next() {
                        return randomMail();
                    }
                    @Override public void remove() {
                        throw new UnsupportedOperationException();
                    }
                };
            }
        };
    }
}
public class PostOffice {
    enum MailHandler {
        GENERAL_DELIVERY {
            @Override boolean handle(Mail m) {
                switch (m.generalDelivery) {
                    case YES:
                        System.out.println("Using general delivery for " + m);
                        return true;
                    default: return false;
                }
            }
        },
        MACHINE_SCAN {
            @Override boolean handle(Mail m) {
                switch (m.scannability) {
                    case UNSCANNABLE: return false;
                    default:
                        switch (m.address) {
                            case INCORRECT: return false;
                            default:
                                System.out.println("Delivering " + m + " automatically");
                                return true;
                        }
                }
            }
        },
        VISUAL_INSPECTION {
            @Override boolean handle(Mail m) {
                switch (m.readability) {
                    case ILLEGIBLE: return false;
                    default:
                        switch (m.address) {
                            case INCORRECT: return false;
                            default:
                                System.out.println("Delivering " + m + " normally");
                                return true;
                        }
                }
            }
        },
        RETURN_TO_SENDER {
            @Override boolean handle(Mail m) {
                switch (m.returnAddress) {
                    case MISSING: return false;
                    default:
                        System.out.println("Returning " + m + " to sender");
                        return true;
                }
            }
        };
        abstract boolean handle(Mail m);
    }
    static void handle(Mail m) {
        for(MailHandler handler : MailHandler.values())
            if(handler.handle(m))
                return;
        System.out.println(m + " is a dead letter");
    }

    public static void main(String[] args) {
        for(Mail m : Mail.generator(5)) {
            System.out.println(m.details());
            handle(m);
            System.out.println("-----------");
        }
    }
}
/* output
Mail: 0, GeneralDelivery: NO2, Scannability: UNSCANNABLE, Readability: YES3, Address: OK1, ReturnAddress: OK1
Delivering Mail: 0 normally
-----------
Mail: 1, GeneralDelivery: NO5, Scannability: YES3, Readability: ILLEGIBLE, Address: OK2, ReturnAddress: OK2
Delivering Mail: 1 automatically
-----------
Mail: 2, GeneralDelivery: YES, Scannability: YES3, Readability: YES1, Address: OK4, ReturnAddress: OK4
Using general delivery for Mail: 2
-----------
Mail: 3, GeneralDelivery: NO4, Scannability: YES3, Readability: YES1, Address: OK3, ReturnAddress: MISSING
Delivering Mail: 3 automatically
-----------
Mail: 4, GeneralDelivery: NO4, Scannability: UNSCANNABLE, Readability: YES1, Address: OK4, ReturnAddress: OK2
Delivering Mail: 4 normally
----------- */

职责链模式的作用体现在了 MailHandler 枚举中，枚举的定义顺序则决定了各个策略在每封邮件上被应用的顺序。该模式会按顺序尝试应用每个策略，直到某个策略执行成功，或者全部策略都执行失败（邮件无法投递）。

用枚举实现状态机

枚举类型很适合实现状态机，一个状态机可以具有有限个特定的状态，它通常根据输入，从一个状态转移到下一个状态，不过也可能存在瞬态（transient states），而一旦任务执行结束，状态机就会立刻离开瞬态。

每个状态都具有某些可接受的输入，不同的输入会使状态机从当前状态转移到不同的新状态。由于 enum 对其实例有严格限制，非常适合用来表现不同的状态和输入。一般而言，每个状态都具有一些相关的输出。

下面介绍一个自动售货机的例子，首先，在一个枚举中定义一系列输入：

public enum Input {
    NICKEL(5), DIME(10), QUARTER(25), DOLLAR(100),
    TOOTHPASTE(100), CHIPS(75), SODA(100), SOAP(20),
    ABORT_TRANSACTION {
        @Override public int amount() { // 不允许
            throw new RuntimeException("ABORT.amount()");
        }
    },
    STOP { // 必须是最后一个实例
        @Override public int amount() { // 不允许
            throw new RuntimeException("SHUT_DOWN.amount()");
        }
    };
    int value;
    Input(int value) { this.value = value;}
    Input() {}
    int amount() { return value;}
    static Random rand = new Random(47);
    public static Input randomSelection() {
        return values()[rand.nextInt(values().length - 1)]; // 不包括 STOP
    }
}

注意，除了两个特殊的 Input 实例之外，其他的 Input 都有相应的价格，因此在接口中定义了 amount() 方法。然而，对那两个特殊 Input 实例而言，调用 amount() 方法并不合适，所以如果程序员调用它们的 amount() 方法就会有异常抛出（在接口内定义了一个方法，然后在你调用该方法的某个实现时就会抛出异常），尽管有些奇怪，但这是枚举的限制所导致的。

VendingMachine 接收到输入后，首先通过 Category 枚举对其分类，这样就可以在类别间切换了。下例演示了 enum 是如何使代码变得更加清晰且易于管理的：

enum Category {
    MONEY(Input.NICKEL, Input.DIME, Input.QUARTER, Input.DOLLAR),
    ITEM_SELECTION(Input.TOOTHPASTE, Input.CHIPS, Input.SODA, Input.SOAP),
    QUIT_TRANSACTION(Input.ABORT_TRANSACTION),
    SHUT_DOWN(Input.STOP);
    private Input[] values;
    Category(Input... values) { this.values = values;}
    private static EnumMap<Input, Category> categories =
            new EnumMap<>(Input.class);
    static {
        for(Category c : Category.class.getEnumConstants())
            for(Input type : c.values)
                categories.put(type, c);
    }
    public static Category categorize(Input input) {
        return categories.get(input);
    }
}
public class VendingMachine {
    private static State state = State.RESTING;
    private static int amount = 0;
    private static Input selection = null;
    enum StateDuration { TRANSIENT }
    enum State{
        RESTING {
            @Override void next(Input input) {
                switch (Category.categorize(input)) {
                    case MONEY:
                        amount += input.amount();
                        state = ADDING_MONEY;
                        break;
                    case SHUT_DOWN:
                        state = TERMINAL;
                    default:
                }
            }
        },
        ADDING_MONEY {
            @Override void next(Input input) {
                switch (Category.categorize(input)) {
                    case MONEY:
                        amount += input.amount();
                        break;
                    case ITEM_SELECTION:
                        selection = input;
                        if(amount < selection.amount())
                            System.out.println("Insufficient money for " + selection);
                        else state = DISPENSING;
                        break;
                    case QUIT_TRANSACTION:
                        state = GIVING_CHANGE;
                        break;
                    case SHUT_DOWN:
                        state = TERMINAL;
                        break;
                    default:
                }
            }
        },
        DISPENSING(StateDuration.TRANSIENT) {
            @Override void next() {
                System.out.println("here is your " + selection);
                amount -= selection.amount();
                state = GIVING_CHANGE;
            }
        },
        GIVING_CHANGE(StateDuration.TRANSIENT) { // 找零
            @Override void next() {
                if(amount > 0) {
                    System.out.println("Your change: " + amount);
                    amount = 0;
                }
                state = RESTING;
            }
        },
        TERMINAL {
            @Override void output() {
                System.out.println("Halted");
            }
        };
        private boolean isTransient = false;
        State() {}
        State(StateDuration trans) { isTransient = true;}
        void next(Input input) {
            throw new RuntimeException("Only call " +
                    "next(Input input) for non-transient states");
        }
        void next() {
            throw new RuntimeException("Only call " +
                    "next() for StateDuration.TRANSIENT states");
        }
        void output() { System.out.println(amount);}
    }
    static void run(Supplier<Input> gen) {
        while(state != State.TERMINAL) {
            state.next(gen.get());
            while(state.isTransient)
                state.next();
            state.output();
        }
    }
    public static void main(String[] args) {
        Supplier<Input> gen = new RandomInputSupplier();
        if(args.length == 1)
            gen = new FileInputSupplier(args[0]);
        run(gen);
    }
}

class RandomInputSupplier implements Supplier<Input> {
//    int count = 0;
    @Override public Input get() {
//        if(count++ < 20)
        return Input.randomSelection();
//        else
//            return Input.STOP;
    }
}
class FileInputSupplier implements Supplier<Input> {
    private Iterator<String> input;
    FileInputSupplier(String fileName) {
        try {
            input = Files.lines(Paths.get(fileName))
                    .skip(1)
                    .flatMap(s -> Arrays.stream(s.split(";")))
                    .map(String::trim)
                    .collect(Collectors.toList())
                    .iterator();
        }catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    @Override public Input get() {
        if(!input.hasNext())
            return null;
        return Enum.valueOf(Input.class, input.next().trim());
    }
}
/* output
25
50
75
here is your CHIPS
0
25
35
Your change: 35
0
25
35
Insufficient money for SODA
35
60
70
75
Insufficient money for SODA
75
Your change: 75
0
Halted */

因为通过 switch 语句在枚举实例中进行选择操作是最常见的方式（注意，为了使 enum 在 switch 语句中的使用变得简单，是需要付出其他代价的），所以在组织多个枚举类型时，常见的问题是“需要在什么 enum 中（即以什么粒度）进行 switch”。通过该例子，会发现在每种 state 下，需要针对输人操作的基本类别进行 switch 操作：投人钱币、选择商品、退出交易、关闭机器。然而，在这些基本分类之下，我们又可以塞人不同类型的钱币，可以选择不同的货物。Category 枚举会对不同的 Input 类型进行分类，因此 categorize() 方法可以在 switch 中生成恰当的 Category。且该方法用一个 EnumMap 实现了高效且安全的查询。

仔细研究 VendingMachine 类，会发现每个状态的区别，以及对于输入的不同响应，其中还有两个瞬时状态。在 run() 方法中，状态机等待着下一个 Input，并一直在各个状态中移动，直到它不再处于瞬时状态。

这里通过两种不同的 Supplier 对象以两种方法测试。RandomInputSupplier 会不停地生成除了 SHUT-DOWN 之外的各种输入。通过长时间地运行 RandomInputSupplier，可以起到健全测试（sanity test）的作用，能够确保该状态机不会进入一个错误状态。另一个是 FileInputSupplier，使用文件以文本的方式来描述输入，然后将它们转换成 enum 实例，并创建对应的 Input 对象。下面是用于生成以上输出的文本文件：

// enum/VendingMachineInput.txt
QUARTER; QUARTER; QUARTER; CHIPS;
QUARTER; DIME; ABORT_TRANSACTION;
QUARTER; DIME; SODA;
QUARTER; DIME; NICKEL; SODA;
ABORT_TRANSACTION;
STOP;

FilelnputSupplier 的构造器将这个文件转换为行级的 Stream 流，并忽略注释行。然后它通过 String.split() 方法将每一行都根据分号拆开，生成一个字符串数组，可以通过先将该数组转化为 Steam，然后执行 flatMap()，来将其注人（前面 FileInputSupplier 中生成的）Stream中。结果将删除所有的空格，并转换为 List<String>，并从中得到 Iterator<String>。

上述设计有个限制：VendingMachine 中会被 State 枚举实例访问到的字段都必须是静态的，这意味着只能存在一个 VendingMachine 实例。不过实际的（嵌入式 Java）应用，也许并不是一个大问题，因为在一台机器上，我们可能只有一个应用程序。

多路并发

当处理多个交互类型时，程序可能会变得相当混乱。举例来说，考虑一个解析并执行数学表达式的系统。里面可能包括 Number.plus(Number), Number.multiply(Number) 等，此处的 Number 是数值对象家族的基类。但是当你要执行 a.plus(b)，并且不知道 a 或 b 的具体类型时，如何保证它们间的相互作用是正确的？

Java 只能进行单路分发，如果你想对多个类型未知的对象进行操作，Java 只会对其中一个类型调用动态绑定机制。这并不能解决当前的问题，所以你最终只能手动检测类型，然后再实现你自己的动态绑定行为。

该问题的解决方法是多路分发（此处为双路分发），多态只能发生在方法调用时，所以，如果想使用两路分发，那么就必须有两个方法调用：第一个方法调用决定第一个未知类型，第二个方法调用决定第二个未知的类型。要使用多路分发，就必须为每一个类型提供一个实际的方法调用，如果要处理两个不同的类型体系，就需要为每个类型体系执行一个方法调用。通常需要设定好某种配置，以便一个方法调用能够引出更多的方法调用，从而能够在这个过程中处理多种类型。要达到这个目的，需要不止一个方法互相配合：每个分发都需要一个方法调用。下面示例（“猜拳”游戏）中对应方法是 compete() 和 eval()，它们都是同一个类型的成员，可以产生三种 Outcome 实例中的一个作为结果：

package fingerGuess;
public enum Outcome { WIN, LOSE, DRAW}

Item 是多路分发类型的接口：

package fingerGuess;
public interface Item {
    Outcome compete(Item it);
    Outcome eval(Paper p);
    Outcome eval(Scissors s);
    Outcome eval(Rock r);
}

每个 Item 类型都提供了方法的对应实现：

public class Paper implements Item {
    @Override public Outcome compete(Item it) {
        return it.eval(this);
    }
    @Override public Outcome eval(Paper p) { return DRAW;}
    @Override public Outcome eval(Scissors s) { return WIN;}
    @Override public Outcome eval(Rock r) { return LOSE;}
    @Override public String toString() { return "Paper";}
}
public class Scissors implements Item{
    @Override public Outcome compete(Item it) {
        return it.eval(this);
    }
    @Override public Outcome eval(Paper p) { return LOSE;}
    @Override public Outcome eval(Scissors s) { return DRAW;}
    @Override public Outcome eval(Rock r) { return WIN;}
    @Override public String toString() { return "Scissors";}
}
public class Rock implements Item{
    @Override public Outcome compete(Item it) {
        return it.eval(this);
    }
    @Override public Outcome eval(Paper p) { return WIN;}
    @Override public Outcome eval(Scissors s) { return LOSE;}
    @Override public Outcome eval(Rock r) { return DRAW;}
    @Override public String toString() { return "Rock";}
}

下面的 RoShamBo1.match() 接收两个 Item 对象作为参数，通过调用 Item.compete() 开始双路分发：

public class RoShamBo1 {
    static final int SIZE = 5;
    private static Random rand = new Random(47);
    public static Item newItem() {
        switch (rand.nextInt(3)) {
            default:
            case 0: return new Scissors();
            case 1: return new Paper();
            case 2: return new Rock();
        }
    }
    public static void match(Item a, Item b) {
        System.out.println(a + " VS " + b + ": " + a.compete(b)); // 多态
    }

    public static void main(String[] args) {
        for(int i = 0; i < SIZE; i++)
            match(newItem(), newItem());
    }
}
/* output
Rock VS Rock: DRAW
Paper VS Rock: WIN
Paper VS Rock: WIN
Paper VS Rock: WIN
Scissors VS Paper: WIN */

要判定 a 的类型，分发机制会在 a 的实际类型的 compete() 内部起到分发的作用。compete() 方法通过调用 eval() 来为另一个类型实现第二次分发。将自身(this)作为参数传入 eval()，会产生一个对重载 eval() 的调用，由此保留了第一次分发的类型信息，当第二次分发结束后，就知道了两个 Item 对象的准确类型。

要配置好多路分发需要很多的工序，不过要记住，它的好处在于方法调用时的优雅的话法，这避免了在一个方法中判定多个对象的类型的丑陋代码。不过，在使用多路分发前，请先明确，这种优雅的代码对你确实有重要的意义。

使用枚举类型分发

直接将 RoShamBo1.java 转换为基于枚举的实现版本是有问题的，因为枚举实例不是类型，无法重载 eval() 方法，无法将枚举实例作为参数类型。不过，还有很多方式可以利用枚举实现多路分发。

一种方法是通过构造方法初始化每个枚举实例，并以“一组”结果作为参数，最终组成类似查询表的结构:

public enum RoShamBo2 implements Competitor<RoShamBo2> {
    PAPER(DRAW, LOSE, WIN),
    SCISSORS(WIN, DRAW, LOSE),
    ROCK(LOSE, WIN, DRAW);
    private Outcome vPaper, vScissors, vRock;
    RoShamBo2(Outcome paper, Outcome scissors, Outcome rock) {
        this.vPaper = paper;
        this.vScissors = scissors;
        this.vRock = rock;
    }
    @Override public Outcome compete(RoShamBo2 it) {
        switch (it) {
            default:
            case PAPER: return vPaper;
            case SCISSORS: return vScissors;
            case ROCK: return vRock;
        }
    }

    public static void main(String[] args) {
        RoShamBo.play(RoShamBo2.class, 5);
    }
}
/* output
ROCK VS ROCK: DRAW
SCISSORS VS ROCK: LOSE
SCISSORS VS ROCK: LOSE
SCISSORS VS ROCK: LOSE
PAPER VS SCISSORS: LOSE */

在 compete() 方法中，一旦两个类型都被确定了，那么唯一的动作就是返回得到的 Outcome。然而，你也可以调用其他方法，甚至是（比如）构造方法中分配的命令对象中的方法。

该例子比之前更短而且易于理解。注意，我们仍然是使用两路分发来判定两个对象的类型。在 RoShamBol.java 中，两次分发都是通过实际的方法调用实现，而在这个例子中，只有第一次分发是实际的方法调用。第二个分发使用的是 switch，不过这样做是安全的，因为 enum 限制了 switch 语句的选择分支。

用来操作枚举的代码是独立的，可以在其他例子中使用。首先，Competiotr 接口定义了一个和另一个 Competitor 竞争的类型：

public interface Competitor<T extends Competitor<T>>{
    Outcome compete(T competitor);
}

然后我们定义了两个静态方法（使用静态是为了避免显式地指定参数类型）。首先， match() 方法中调用了 compete() 方法，让两个 Competitor 竞争，可以看到此处类型参数只需要是 Competitor<T>。但是在 play() 方法中，类型参数必须同时是 Enum<T>（因为要放在 Enums.random() 中使用）和 Competitor<T>（因为要传给 match() ）。

public class RoShamBo {
    public static <T extends Competitor<T>> void match(T a, T b) {
        System.out.println(a + " VS " + b + ": " + a.compete(b));
    }
    public static <T extends Enum<T> & Competitor<T>> void play(Class<T> rsbClass, int size) {
        for(int i = 0; i < size; i++)
            match(Enums.random(rsbClass), Enums.random(rsbClass));
    }
}

play() 方法没有将类型参数 T 作为返回值，因此，似乎你应该在 Class<T> 中用通配符(<?>)来取代主要的参数声明。然而通配符无法继承多个基类，因此我们必须使用上面的表达式。

使用常量特定方法

由于常量特定方法允许为不同的枚举实例提供不同的方法实现，所以看起来似乎是实现多路分发的完美解决方案。但是即使可以通过这种方式赋予枚举实例不同的行为，枚举实例也仍然不是类型，因此无法将它们作为方法签名中的参数类型。对于这个例子，最好的办法是构建一个 switch 语句:

public enum RoShamBo3 implements Competitor<RoShamBo3> {
    PAPER {
        @Override public Outcome compete(RoShamBo3 it) {
            switch (it) {
                default:
                case PAPER: return DRAW;
                case SCISSORS: return LOSE;
                case ROCK: return WIN;
            }
        }
    },
    SCISSORS {
        @Override public Outcome compete(RoShamBo3 it) {
            switch (it) {
                default:
                case PAPER: return WIN;
                case SCISSORS: return DRAW;
                case ROCK: return LOSE;
            }
        }
    },
    ROCK {
        @Override public Outcome compete(RoShamBo3 it) {
            switch (it) {
                default:
                case PAPER: return LOSE;
                case SCISSORS: return WIN;
                case ROCK: return DRAW;
            }
        }
    };
    @Override public abstract Outcome compete(RoShamBo3 it);
    public static void main(String[] args) {
        RoShamBo.play(RoShamBo3.class, 5);
    }
}
/* output
ROCK VS ROCK: DRAW
SCISSORS VS ROCK: LOSE
SCISSORS VS ROCK: LOSE
SCISSORS VS ROCK: LOSE
PAPER VS SCISSORS: LOSE */

虽然该例子没问题，但是相比下，RoShamBo2.java 在新增类型时需要的代码更少且简洁。

RoShamBo3 也可以简化一下：

public enum RoShamBo4 implements Competitor<RoShamBo4> {
    PAPER {
        @Override public Outcome compete(RoShamBo4 competitor) {
            return compete(ROCK, competitor);
        }
    },
    SCISSORS {
        @Override public Outcome compete(RoShamBo4 competitor) {
            return compete(PAPER, competitor);
        }
    },
    ROCK {
        @Override public Outcome compete(RoShamBo4 competitor) {
            return compete(SCISSORS, competitor);
        }
    };
    Outcome compete(RoShamBo4 loser, RoShamBo4 opponent) {
        return (opponent == this) ? Outcome.DRAW
                : (loser == opponent) ? Outcome.WIN : Outcome.LOSE;
    }
    public static void main(String[] args) {
        RoShamBo.play(RoShamBo4.class, 5);
    }
}
/* output
ROCK VS ROCK: DRAW
SCISSORS VS ROCK: LOSE
SCISSORS VS ROCK: LOSE
SCISSORS VS ROCK: LOSE
PAPER VS SCISSORS: LOSE */

此处的第二个分发是由两个参数版本的 compete() 执行的，它执行了一系列比较操作，因此看起来和 switch 的行为很相似。它更简短，却更难理解。如果将其用于大型系统的开发，这一混淆可能会削弱系统的可维护性。

使用 EnumMap 分发

使用 EnumMap 可以实现“真正的”双路分发，它是专门为 enum 设计的高效 Map。由于目标是在两个未知类型中切换，因此由 EnumMap 组成的 EnumMap（嵌套 EnumMap）可以实现双路分发。

public enum RoShamBo5 implements Competitor<RoShamBo5> {
    PAPER, SCISSORS, ROCK;
    static EnumMap<RoShamBo5, EnumMap<RoShamBo5, Outcome>>
            table = new EnumMap<>(RoShamBo5.class);
    static {
        for(RoShamBo5 it : values())
            table.put(it, new EnumMap<>(RoShamBo5.class));
        initRow(PAPER, DRAW, LOSE, WIN);
        initRow(SCISSORS, WIN, DRAW, LOSE);
        initRow(ROCK, LOSE, WIN, DRAW);
    }
    static void initRow(RoShamBo5 it, Outcome vPaper, Outcome vScissors, Outcome vRock) {
        EnumMap<RoShamBo5, Outcome> row = table.get(it);
        row.put(PAPER, vPaper);
        row.put(SCISSORS, vScissors);
        row.put(ROCK, vRock);
    }
    @Override public Outcome compete(RoShamBo5 it) {
        return table.get(this).get(it);
    }

    public static void main(String[] args) {
        RoShamBo.play(RoShamBo5.class, 5);
    }
}
/* output
ROCK VS ROCK: DRAW
SCISSORS VS ROCK: LOSE
SCISSORS VS ROCK: LOSE
SCISSORS VS ROCK: LOSE
PAPER VS SCISSORS: LOSE */

这里 EnumMap 是用一个 static{} 子句进行初始化的，可以看到对 initRow() 的调用是类似表格的结构。注意 compete() 方法，其在内部的一条语句内发生了两次分发。

使用二维数组

可以注意到，每个 enum 实例都有一个固定的值（基于其声明的次序），并且可以通过 ordinal() 方法取得该值。因此可以进一步简化，使用一个二维数组将竞争者映射到结果，便可以实现最简单的方案（而且有可能是最快的，尽管 EnumMap 用了内部数组）:

public enum RoShamBo6 implements Competitor<RoShamBo6> {
    PAPER, SCISSORS, ROCK;
    private static Outcome[][] table = {
            {DRAW, LOSE, WIN},
            {WIN, DRAW, LOSE},
            {LOSE, WIN, DRAW}
    };
    @Override public Outcome compete(RoShamBo6 other) {
        return table[this.ordinal()][other.ordinal()];
    }

    public static void main(String[] args) {
        RoShamBo.play(RoShamBo6.class, 5);
    }
}
/* output
ROCK VS ROCK: DRAW
SCISSORS VS ROCK: LOSE
SCISSORS VS ROCK: LOSE
SCISSORS VS ROCK: LOSE
PAPER VS SCISSORS: LOSE */

该例子看起来更易于理解和修改，但是它并没有之前的示例那么“安全"，因为它使用了数组。如果处理一个更大的数组，则可能会得到错误的数组大小并且如果测试未覆盖到所有的可能情况，则也许会出现一些不易发现的问题。

所有这些解决方案其实都是各种不同类型的表，但仍然值得去探索各种表的表现方式，从而找到最合适的那一种。注意，该例在给定若干常量输入的情况下，它只能生成一个常量输出。不过也可以通过 table 来生成函数对象(function object)。对于某些特定类型的问题，“表驱动模式”(table-driven code)的概念是非常强大的。

支持模式匹配的新特性

可以认为模式匹配（pattern matching）是在 switch 关键字上进行了显著的功能扩充。它是分成了多个模块，历经 Java 的多个版本持续实现的。这保证了每个模块在其他模块加人前都可以安全地运行。最后，所有的模块集中到一起，就产生了这个新特性。

这种拆分实现的方式使得人们在面对跨多个版本增加的多个“子特性”时会有点团惑。试图通过逐个分析各个单独模块来理解模式匹配并不是明智的选择。在下面部分，本文将所有支持模式匹配的模块都汇总到了一起以减少理解上的困惑。

新特性：switch 中的箭头语法

JDK 14 增加了在 switch 中使用不同语法的 case 的能力：

import static java.util.stream.IntStream.range;

public class ArrowInSwitch {
    static void colons(int i) {
        switch (i) {
            case 1: System.out.println("one");
                    break;
            case 2: System.out.println("two");
                    break;
            default: System.out.println("default");
        }
    }
    static void arrow(int i) {
        switch (i) {
            case 1 -> System.out.println("one");
            case 2 -> System.out.println("two");
            default -> System.out.println("default");
        }
    }
    public static void main(String[] args) {
        range(0, 3).forEach(i -> colons(i));
        range(0, 3).forEach(i -> arrow(i));
    }
}
/* output
default
one
two
default
one
two */

在 colons() 中，可以看到为了防止继续向下执行，每个 case 语句（最后一个 default 以外）后面都有必要加上 break。而在 arrows() 中替换为箭头后便不再需要 break 语句了。然而这只是箭头的一部分功能而已。不能在同一 switch 中同时使用冒号和箭头。

新特性：switch 中的 case null

JDK 17 新增了（预览）功能，可以在 switch 中引人原本非法的 case null。以前只能在 switch 的外部检查是否为 null，如下所示：

public class CaseNull {
    static void old(String s) {
        if(s == null) {
            System.out.println("null");
            return;
        }
        switch (s) {
            case "XX" -> System.out.println("XX");
            default -> System.out.println("default");
        }
    }
    static void checkNull(String s) {
        switch (s) {
            case "XX" -> System.out.println("XX");
            case null -> System.out.println("null");
            default -> System.out.println("default");
        }
    }
    static void defaultOnly(String s) {
        switch (s) {
            case "XX" -> System.out.println("XX");
            default -> System.out.println("default");
        }
    }
    static void combineNullAndCase(String s) {
        switch (s) {
          //  case "XX", null -> System.out.println("XX"); // jdk 21 invalid
            default -> System.out.println("default");
        }
    }
    static void combineNullAndDefault(String s) {
        switch (s) {
            case "XX" -> System.out.println("XX");
            case null, default -> System.out.println("default");
        }
    }
    static void test(Consumer<String> cs) {
        cs.accept("XX");
        cs.accept("YY");
        try {
            cs.accept(null);
        } catch (NullPointerException e) {
            System.out.println(e.getMessage());
        }
    }

    public static void main(String[] args) {
        test(CaseNull::old);
        test(CaseNull::checkNull);
        test(CaseNull::defaultOnly);
        test(CaseNull::combineNullAndDefault);
    }
}
/* output
XX
default
null
XX
default
null
XX
default
Cannot invoke "String.hashCode()" because "<local1>" is null
XX
default
default */

可以看到，null 现在在 switch 中可以作为合法的 case 了。

default 是否会覆盖 null 的情况呢？从 defaultOnly() 可以看出 default 并不会捕获 null，而如果又没有使用 case null，就会抛出 NullPointException 异常。Java 声称 switch 会覆盖所有可能的值，即使它实际并未覆盖 null。这是向后兼容性导致的问题一一如果 Java 突然开始强制进行 null 检查，那么大部分已有代码会无法通过编译。

为了方便，可以像 combineNullAndDefault() 中那样将 case null 和 default 合并。

新特性：将 switch 作为表达式

switch 之前只能是一个语句，不会返回结果。JDK 14 使得 switch 可以作为一个表达式使用，即可以得到一个值：

public class SwitchExpression {
    static int colon(String s) {
        var result = switch (s) {
            case "i": yield 1; // 新关键字
            case "j": yield 2;
            case "k": yield 3;
            default:yield 0;
        };
        return result;
    }
    static int arrow(String s) {
        var result = switch (s) {
            case "i" -> 1;
            case "j" -> 2;
            case "k" -> 3;
            default -> 0;
        };
        return result;
    }

    public static void main(String[] args) {
        for(var s : new String[]{"i", "j", "k", "z"})
            System.out.format("%s %d %d%n", s, colon(s), arrow(s));
    }
}
/* output
i 1 1
j 2 2
k 3 3
z 0 0 */

在 colon() 中，使用旧的冒号语法时，可以使用新的关键字 yield 从 switch 中返回结果。注意，使用 yield 时不要再用 break，如果再加上 break，会在编译时产生错误消息“试图跳出 switch 表达式"(attempt to break out of a switch expression)。

如果试图在 switch 语句中使用 yield，编译器会产生错误消息“在 switch 表达式外部 yield”。

arrow() 实现同样效果，但是更清晰和紧凑。可以为 TrafficLight.java 改进：

public class EnumSwitch {
    enum Signal { GREEN, YELLOW, RED}
    Signal color = Signal.RED;
    public void change() {
        color = switch (color) {
            case RED -> Signal.GREEN;
            case GREEN -> Signal.YELLOW;
            case YELLOW -> Signal.RED;
        };
    }
}

编译器会确保在修改代码时不会缺少 case，即如果在不加上 case BLUE 的情况下将 BLUE 加到 enum Signal 中，则会出现“switch 表达式未覆盖所有可能输入值”。

如果一个 case 需要多个语句或表达式，可以放到花括号中：

enum CelestialBody {
    MERCURY, VENUS, EARTH, MARS, JUPITER,
    SATURN, URANUS, NEPTUNE, PLUTO
}
public class Planets {
    public static String classify(CelestialBody b) {
        var result = switch (b) {
            case MERCURY, VENUS, EARTH, MARS, JUPITER,
                    SATURN, URANUS, NEPTUNE -> {
                System.out.print("A planet is ");
                yield b.toString();
            }
            case PLUTO -> {
                System.out.print("Not a planet: ");
                yield b.toString();
            }
        };
        return result;
    }

    public static void main(String[] args) {
        System.out.println(classify(CelestialBody.MARS));
        System.out.println(classify(CelestialBody.PLUTO));
    }
}
/* output
A planet is MARS
Not a planet: PLUTO */

从多行组成的 case 表达式中生成结果时，即使用箭头语法，也要用 yield。

新特性：智能转型

JDK 16 完成了“针对 instanceof 的模式匹配”的定稿（JEP 394），该名字称其为“模式匹配支持”（support for pattern matching）可能会更恰当。在 Kollin 语言中，该特性被简单地称为“智能转型”（smart casting)，因为一旦确定类型后，就永远不需要对其转型了。

public class smartCasting {
    static void dumb(Object x) {
        if(x instanceof String) {
            String s = (String)x;
            if(s.length() > 0)
                System.out.format("%d %s%n", s.length(), s.toUpperCase());
        }
    }
    static void smart(Object x) {
        if(x instanceof String s && s.length() > 0)
            System.out.format("%d %s%n", s.length(), s.toUpperCase());
    }
    static void wrong(Object x) {
        // "||" 永远不会生效
        // if(x instanceof String s || s.length() > 0) {}
        // error:cannot find symbol
    }

    public static void main(String[] args) {
        dumb("dumb");
        smart("smart");
    }
}
/* output
4 DUMB
5 SMART */

在 dumb() 中，一旦 instanceof 确定了 x 是 String 后，就必须显式地将它转型为 String s。否则就得在该函数中其余的地方到处插入转型操作。但在 smart() 中，注意 instanceof String s 自动用 String 类型创建了一个新的变量 s。s 在整个作用域中都可用，即使是在剩余的 if 条件中，如 && s.length() > 0。

从 wrong() 可以看出，在 if 智能转型表达式中只能使用 &&。使用 || 则意味着可能 x 是个 instanceof String，也可能 s.length() > 0。但这也就意味着 x 也可能不是 String, 在这种情况下，Java 就不会将 x 智能转型以生成 s，因此 s 在 || 右侧是不可用的。

JEP 384 称 s 为模式变量（pattern variable）。加入该特性是作为模式匹配的构建块而引入的。

该特性可以产生某些奇怪的作用域行为：

public class OddScoping {
    static void f(Object x) {
        if(! (x instanceof String s)) {
            System.out.println("Not a String");
            throw new RuntimeException();
        }
        // 此处 s 仍在作用域中
        System.out.println(s.toUpperCase());
    }
    public static void main(String[] args) {
        f("Curiouser");
        f(null);
    }
}
/* output
CURIOUSER
Not a String
Exception in thread "main" java.lang.RuntimeException
    at enumerations.OddScoping.f(OddScoping.java:7)
    at enumerations.OddScoping.main(OddScoping.java:14) */

只有在不引入会引发异常的语句时，s 才在作用域中。即如果注释掉 throw new RuntimeException()，编译器便会告诉你它无法在那里找到 s。

新特性：模式匹配

模式匹配在 JDK 17 中还是预览特性，还需要用到示例注释中给出的编译器和运行时标志。Java 的模式匹配仍在开发中，和成熟的模式匹配系统（如 Kotlin, Scala, 以及 Python 中的那些）相比，功能还相当有限。

违反里氏替换原则

基于继承的多态性实现了基于类型的行为，但是要求这些类型都在同一个继承层次结构中。而模式匹配也实现了基于类型的行为，却并不要求类型全都具有相同的接口，或都处于相同的继承层次结构中。

这是一种不同的反射使用方式，仍然需要在运行时确定类型，但该方式比反射更加正式、更加结构化。

如果感兴趣的类型全都具有共同的基类，并且只会使用公共基类中定义的方法，那么就遵循了里氏替换原则（Liskov Substitution Principle, LSP)。在这种情况下，模式匹配就不是必需的了一一只需使用普通的继承多态性即可。

interface LifeForm {
    String move();
    String react();
}
class Worm implements LifeForm {
    @Override public String move() {
        return "Worm::move";
    }
    @Override public String react() {
        return "Worm::react";
    }
}
class Giraffe implements LifeForm {
    @Override public String move() {
        return "Giraffe::move";
    }
    @Override public String react() {
        return "Giraffe::react";
    }
}
public class NormalLiskov {
    public static void main(String[] args) {
        Stream.of(new Worm(), new Giraffe())
                .forEach(lf -> System.out.println(
                        lf.move() + " " + lf.react()));
    }
}
/* output
Worm::move Worm::react
Giraffe::move Giraffe::react */

所有方法都完全定义在 LifeForm 接口中，实现类中也并没有增加任何方法。

但如果需要增加难以放在基类中的方法呢？比如某些蠕虫身体被切断后可以再生，而长颈鹿肯定做不到。长颈鹿可以踢人，但是很难想象怎样可以在基类中表现出该行为，同时又不会使 Worm 错误地实现（该行为)。Java 集合库遇到了这种问题，并试图以一种笨拙的方式解决：在基类中增加“可选”方法，某些子类可以实现该方法，而另一些子类则不实现。这种方法遵循了里氏替换原则，但造成了混乱的设计。

Java 的基本灵感来自一种叫作 SmallTalk 的动态语言，它会利用已有的类并增加方法，以此实现代码复用。以 Smalltalk 的设计方式来实现一套 "pet"（宠物）继承层次结构，可能最终看起来是这样的:

public class Pet {
    void feed() {}
}
class Dog extends Pet {
    void walk() {}
}
class Fish extends Pet {
    void changeWater() {}
}

我们利用了基本 Pet 的功能性，并通过增加我们需要的方法扩展了该类。这不同于本书中一贯的主张（正如 NormalLiskov.java 所示）：应该仔细地设计基类，以包含所有继承层次结构中可能需要的方法，因此遵循了里氏替换原则。虽然很有前景，但是不切实际，试图将基于动态类型的 SmallTalk 模型强制引入基于静态类型的 Java 系统，这必然会造成妥协。在某些情况下，这些妥协可能是行不通的。模式匹配允许使用 SmallTalk 的方式向子类添加新方法，同时仍然保持里氏替换原则的大部分形式。基本上模式匹配允许违反里氏替换原则，而不会产生不可控的代码。

有了模式匹配，就可以通过为每种可能的类型逬行检查并编写不同的代码，来处理 Pet 继承层次结构的非里氏替换原则的性质：

public class PetPatternMatch {
    static void careFor(Pet p) {
        switch (p) {
            case Dog d -> d.walk();
            case Fish f -> f.changeWater();
            case Pet sp -> sp.feed();
        }
    }
    static void petCare() {
        List.of(new Dog(), new Fish())
                .forEach(p -> careFor(p));
    }
}

switch(p) 中的 p 称为选择器表达式（selector expression）。在模式匹配诞生之前，选择器表达式只能是完整的基本类型（char, byte, short 或 int)，对应的包装类形式(Character, Byte, Short 或 Integer)，String 或 enum 类型。有了模式匹配，选择器表达式扩展到可以支持任何引用类型。此处的选择器表达式可以是 Dog, Fish 或 Pet。

注意，这和继承层次结构中的动态绑定类似，但是并没有将不同类型的代码放在重写的方法中，而是将其放在了不同的 case 表达式中。

编译器强制增加了 case Pet，若不增加，switch 就无法覆盖所有可能的输入值。为基类使用接口可以消除该约束，但会增加另一约束。下面这个示例被放置在自己的 package 中，以防止命名冲突：

sealed interface Pet {
    void feed();
}
final class Dog implements Pet {
    @Override public void feed() {}
    void walk() {}
}
final class Fish implements Pet {
    @Override public void feed() {}
    void changeWater() {}
}
public class PatPatternMatch2 {
    static void careFor(Pet p) {
        switch (p) {
            case Dog d -> d.walk();
            case Fish f -> f.changeWater();
        }
    }
    static void petCare() {
        List.of(new Dog(), new Fish())
                .forEach(p -> careFor(p));
    }
}

如果 Pet 没有用 sealed（密封，Java 15 引人的关键字，用于限制类或方法的随意继承扩充）修饰，编译器会再次发出警告“switch 语句没有覆盖所有可能的输入值”。这里的具体原因则是 interface Pet 可以被其他任何文件中的任何类实现，所以破坏了 switch 语句程盖的完整性。通过将 Pet 修饰为 sealed 的，编译器就能确保 switch 覆盖到所有可能的Pet类型。

模式匹配不会像继承多态性那样将你约束在单一继承层次结构中一一你可以匹配任意类型。想要这样做，就需要将 Object 传人 switch:

record XX() {}
public class ObjectMatch {
    static String match(Object o) {
        return switch (o) {
            case Dog d -> "Walk the dog";
            case Fish f -> "Change the fish water";
            case Pet sp -> "Not dog or fish";
            case Integer i -> "Integer " + i;
            case String s -> "String " + s;
            case String[] sa -> String.join(", ", sa);
            case XX xx -> "XX: " + xx;
            case null -> "null";
            default -> "Something else";
        };
    }

    public static void main(String[] args) {
        List.of(new Dog(), new Fish(), new Pet(),
                "Oscar", Integer.valueOf(12),
                Double.valueOf("47.47"),
                new String[]{"to", "the", "point"},
                new XX()).forEach(
                        p -> System.out.println(match(p)));
    }
}
/* output
Walk the dog
Change the fish water
Not dog or fish
String Oscar
Integer 12
Something else
to, the, point
XX: XX[] */

将 Object 参数传入 switch 的时候，编译器会要求有 default 存在，也是为了程盖所有可能的输人值（不过 null 除外，编译器并不要求存在为 null 的 case，尽管这种情况也可能发生)。

注意，在 JDK 21 中，null 只能和 default 合并在一起，而在 JDK 17 预览中还可以将 null 和普通模式合并。

守卫(JDK 21 未实现)

守卫（guard）使你可以进一步细化匹配条件，而不只是简单地匹配类型。它是出现在类型判断和 && 后的一项测试。守卫可以是任何布尔表达式，如果选择器表达式和 case 的类型相同，并且守卫判断为 true，那么模式就匹配上了:

// 该部分为 JDK 17 预览功能，且在 JDK 21 中还未正式使用
sealed interface Shape {
  double area();
}

record Circle(double radius) implements Shape {
  @Override public double area() {
    return Math.PI * radius * radius;
  }
}

record Rectangle(double side1, double side2)
  implements Shape {
  @Override public double area() {
    return side1 * side2;
  }
}

public class Shapes {
    static void classify(Shape s) {
        System.out.println(switch(s) {
          case Circle c && c.area() < 100.0
            -> "Small Circle: " + c;
          case Circle c -> "Large Circle: " + c;
          case Rectangle r && r.side1() == r.side2()
            -> "Square: " + r;
          case Rectangle r -> "Rectangle: " + r;
        });
    }
    public static void main(String[] args) {
        List.of(
          new Circle(5.0),
          new Circle(25.0),
          new Rectangle(12.0, 12.0),
          new Rectangle(12.0, 15.0)
        ).forEach(t -> classify(t));
    }
}

支配性

switch 中 case 语句的顺序很重要，如果基类先出现，就会支配任何出现在后面的 case：

sealed interface Base {}
record Derived() implements Base {}
public class Dominance {
    static String test(Base base) {
        return switch (base) {
            case Derived d -> "Derived";
            case Base b -> "B";
        };
    }
}

如果将基类那行上移，就意味着 switch 永远不会测试到 Derived，因为任何子类都会被 case Base 捕获。这时编译器就会报错，“该 case 标签被前面的 case 标签支配了”(this case label is dominated by a preceding case label)。

覆盖范围

模式匹配会引导你逐渐使用 sealed 关键字，这有助于确保你已覆盖了所有可能传人选择器表达式的类型。不过接下来再看一个示例：

sealed interface Transport {}
record Bicycle(String id) implements Transport {}
record Glider(int size) implements Transport {}
record Surfboard(double weight) implements Transport {}

// 取消注释就会出现错误
//record Skis(int length) implements Transport {}
public class SealedPatternMatch {
    static String exhaustive(Transport t) {
        return switch (t) {
            case Bicycle b -> "Bicycle: " + b.id();
            case Glider g -> "Glider: " + g.size();
            case Surfboard s -> "Surfboard: " + s.weight();
        };
    }

    public static void main(String[] args) {
        List.of(new Bicycle("Bob"), new Glider(64), new Surfboard(1.5))
                .forEach(t -> System.out.println(exhaustive(t)));
        try {
            exhaustive(null);
        } catch (NullPointerException e) {
            System.out.println("Not exhaustive: " + e);
        }
    }
}
/* output
Bicycle: Bob
Glider: 64
Surfboard: 1.5
Not exhaustive: java.lang.NullPointerException */

sealed interface Transport 是通过 record 实现的，record 自动就是 final 的。如果增加了新的类型，编译器就会检测出来并告知，但是从上例中可以看出，编译器并未强制覆盖 null，如果加上 case null，就可以防止出现异常。但是编译器在此处帮不了你，显然是因为这会影响到太多已有的 switch 代码。

虽然模式匹配对于 Java 是一项改进，但也遭遇其他新增特性的问题：由于向后兼容性的问题，它只能是相对更强大的 Scala 及 Kotlin 版本的某种不完全实现。

理想情况下，Java 的模式匹配足以解决问题了。不过，如果你发现自己对模式匹配的依赖非常强烈，那么你可能需要一个比 Java 所提供的功能的更完整的功能集。Kotin 语言有着更全面的模式匹配能力，而且能生成可以无缝放入现有 Java 程序的类文件。

总结

虽然 Java 枚举明显比 C 或 C++ 中的 enum 更复杂和先进，但它仍然是个“小”功能。但是它的价值却很大，有时正是它给了最合适的杠杆来优雅而清晰地解决问题。优雅非常重要，而清晰则可以决定一个解决方案是成功还是失败的。

对于清晰性这一点，一个困惑之源是 Java 1.0 的失败选择：使用术语“enumeration", 而不是常见且已被广泛接受的术语“iterator”，来表示一个从序列中依次选取元素的对象（如之前所述）。有些语言基至将枚举的数据类型称为“enumerator”，这个错误后来被 Java 修正了，但是 Enumeration 接口显然无法简单地直接移除，因此它仍然会存在于在一些老旧代码、库以及文档中。

hashtag枚举类型的基本特性

hashtag静态导入枚举类型

hashtag在枚举类型中增加自定义方法

hashtag重载方法

hashtag在 switch 语句中使用枚举

hashtagvalues() 方法的神秘之处

hashtag实现，非继承

hashtag随机选择

hashtag使用接口组织枚举

hashtag用 EnumSet 来代替标识

hashtag使用 EnumMap

hashtag常量特定方法

hashtag用枚举实现职责链模式

hashtag用枚举实现状态机

hashtag多路并发

hashtag使用枚举类型分发

hashtag使用常量特定方法

hashtag使用 EnumMap 分发

hashtag使用二维数组

hashtag支持模式匹配的新特性

hashtag新特性：switch 中的箭头语法

hashtag新特性：switch 中的 case null

hashtag新特性：将 switch 作为表达式

hashtag新特性：智能转型

hashtag新特性：模式匹配

hashtag违反里氏替换原则

hashtag守卫(JDK 21 未实现)

hashtag支配性

hashtag覆盖范围

hashtag总结