Java枚举类型

1.使用enum状态机：一个状态机可以具有有限个特定的状态，根据输入从一个状态转移到下一个状态。在枚举类中写一个抽象方法，然后枚举类中的每个成员都继承该方法。

public enum Colour {
    Blue {
        @Override
        public Colour c() {
            return Red;
        }

        @Override
        public String s() {
            return "蓝色";
        }
    },
    Red {
        @Override
        public Colour c() {
            return Black;
        }

        @Override
        public String s() {
            return "红色";
        }
    },
    Black {
        @Override
        public Colour c() {
            return this;
        }

        @Override
        public String s() {
            return "黑色";
        }
    };

    public abstract Colour c();

    public abstract String s();

    public static void main(String[] args) {
        Colour colour = Colour.Blue;
        System.out.println("你选择了：" + colour.s());
        colour = colour.c();
        System.out.println("你选择了：" + colour.s());
        colour = colour.c();
        System.out.println("你选择了：" + colour.s());
    }
}

2.多路分发：就是一个函数处理多种类型。使用两路分发，必须有两个方法调用：第一个方法调用决定第一个未知类型，第二个方法调用决定第二个未知的类型。还要为每一个类型提供一个实际的方法调用，要处理两个不同的类型体系，就需要为每个类型体系执行一个方法调用。

enum SoThat {
    AA, BB, CC
}

interface Letter {
    SoThat compete(Letter letter);

    SoThat eval(A a);

    SoThat eval(B b);

    SoThat eval(C c);
}

class A implements Letter {

    @Override
    public SoThat compete(Letter letter) {
        return letter.eval(this);
    }

    @Override
    public SoThat eval(A a) {
        System.out.print("A vs A：");
        return SoThat.BB;
    }

    @Override
    public SoThat eval(B b) {
        System.out.print("A vs B：");
        return SoThat.AA;
    }

    @Override
    public SoThat eval(C c) {
        System.out.print("A vs C：");
        return SoThat.CC;
    }
}

class B implements Letter {

    @Override
    public SoThat compete(Letter letter) {
        return letter.eval(this);
    }

    @Override
    public SoThat eval(A a) {
        System.out.print("B vs A：");
        return SoThat.CC;
    }

    @Override
    public SoThat eval(B b) {
        System.out.print("B vs B：");
        return SoThat.BB;
    }

    @Override
    public SoThat eval(C c) {
        System.out.print("B vs C：");
        return SoThat.CC;
    }
}

class C implements Letter {

    @Override
    public SoThat compete(Letter letter) {
        return letter.eval(this);
    }

    @Override
    public SoThat eval(A a) {
        System.out.print("C vs A：");
        return SoThat.AA;
    }

    @Override
    public SoThat eval(B b) {
        System.out.print("C vs B：");
        return SoThat.AA;
    }

    @Override
    public SoThat eval(C c) {
        System.out.print("C vs C：");
        return SoThat.BB;
    }
}

public class Test {
    public static void main(String[] args) {
        Letter l1 = new A();
        Letter l2 = new B();
        SoThat soThat = l1.compete(l2);
        System.out.println(soThat);
    }
}