使用enum的状态机-多路分支

import java.util.Random;

/**
 * 枚举类型非常适合用来创建状态机。
 * 一个状态机可以具有有限个特定的状态，他通常根据输入，从一个状态转移到下一个状态，不过也可能存在瞬时状态，而一旦任务执行解散
 * 状态机就会立刻离开瞬时状态
 * 每个状态都具有某些可接受的输入，不同的输入会使状态机从当前转改转移到不同的新状态
 * 由于enum对其实例有严格限制，非常适合用来表现不同的状态和输入。
 */
public enum Input {
    NICKEL(5),DIME(10),QUARTER(25),DOLLAR(100),
    TOOTHPASTE(200), CHIPS(75),SODA(100),SOAP(50),
    ABORT_TRANSACTION{
        public int amount() {
            throw new RuntimeException("ABORT.amount");
        }
    },
    STOP {
        public int amount() {
            throw new RuntimeException("STOP.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)];
    }
}

多路分发

import java.util.Random;

public class RoShamBo1 {
    static final int SIZE = 20;
    private static Random random =  new Random(47);

    public static Item newItem() {
        switch (random.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());
        //}
        match(newItem(), newItem());
    }
}

public class Rock implements Item{
    @Override
    public Outcome compete(Item item) {
        return item.eval(this);
    }

    @Override
    public Outcome eval(Paper p) {
        return Outcome.WIN;
    }

    @Override
    public Outcome eval(Scissors s) {
        return Outcome.LOSE;
    }

    @Override
    public Outcome eval(Rock r) {
        return Outcome.DRAW;
    }

    @Override
    public String toString() {
        return "Rock";
    }
}

import com.sun.corba.se.impl.oa.toa.TOA;

public class Scissors implements Item{
    @Override
    public Outcome compete(Item item) {
        return item.eval(this);
    }

    @Override
    public Outcome eval(Paper p) {
        return Outcome.LOSE;
    }

    @Override
    public Outcome eval(Scissors s) {
        return Outcome.DRAW;
    }

    @Override
    public Outcome eval(Rock r) {
        return Outcome.WIN;
    }

    @Override
    public String toString() {
        return "Scissors";
    }
}

public class Paper implements Item{

    @Override
    public Outcome compete(Item item) {
        return item.eval(this);
    }

    @Override
    public Outcome eval(Paper p) {
        return Outcome.DRAW;
    }

    @Override
    public Outcome eval(Scissors s) {
        return Outcome.WIN;
    }

    @Override
    public Outcome eval(Rock r) {
        return Outcome.LOSE;
    }

    @Override
    public String toString() {
        return "Paper";
    }
}

public enum Outcome {
    WIN,
    LOSE,
    DRAW
}

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