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

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

RoShamBo2.java

import static enums.TEST0006.Outcome.*;

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, 20);
    }
}

Competitor.java

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

Outcome.java

public enum Outcome {WIN, LOSE, DRAW}

RoShamBo.java

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

Enums.java

import java.util.Random;

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

运行结果如下：

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

RoShamBo2.java 比最初的版本更为简单明了，因此也更容易理解。注意，你仍然在使用两路分发来确定这两个对象的类型。在 RoShamBo1.java 中，两路的分发都是通过虚拟方法调用的。在这里，只有第一次分发使用了虚拟方法调用，第二次分发用的是 switch 。不过这样做是安全的，因为枚举限制了 switch 中的状态可选范围。

用来操作枚举的代码是独立的，因此也可以放到其他例子中使用。首先，Competitor（竞争者）接口定义了一个和另一个 Competitor 竞争的类型：

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

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