一、枚举类型——使用常量特定方法分发

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

RoShamBo3.java

import static enums.TEST0006.Outcome.*;

public enum RoShamBo3 implements Competitor<RoShamBo3> {
    PAPER {
        @Override
        public Outcome compete(RoShamBo3 it) {
            switch (it) {
                default: // To placate the compiler
                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, 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)];
    }
}

运行结果如下：

虽然 RoShamBo3.java 代码可以运行，看起来也没什么问题，但相比之下，RoShamBo2.java 的方案似乎在新増类型时需要的代码更少，因此看起来也更简洁易懂。

不过，RoShamBo3.java 也可以简化为以下版本:

RoShamBo4.java

public enum RoShamBo4 implements Competitor<RoShamBo4> {
    ROCK {
        @Override
        public Outcome compete(RoShamBo4 opponent) {
            return compete(SCISSORS, opponent);
        }
    },
    SCISSORS {
        @Override
        public Outcome compete(RoShamBo4 opponent) {
            return compete(PAPER, opponent);
        }
    },
    PAPER {
        @Override
        public Outcome compete(RoShamBo4 opponent) {
            return compete(ROCK, opponent);
        }
    };

    Outcome compete(RoShamBo4 loser, RoShamBo4 opponent) {
        return ((opponent == this) ? Outcome.DRAW
                : ((opponent == loser) ? Outcome.WIN
                : Outcome.LOSE));
    }

    public static void main(String[] args) {
        RoShamBo.play(RoShamBo4.class, 20);
    }
}

运行结果如下：

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