一、枚举类型——多路分发

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

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

这个问题的解决方法就是多路分发（此处称为双路分发，因为只有两路）。多态只能在方法调用时发生，所以如果你要使用双路分发，就必须执行两次方法调用：第一次用来确定第一个未知类型，第二次用来确定第二个未知类型。要使用多路分发，就必须对每个类型都进行虚拟调用——如果是在操作两个不同的交互类型层次结构，则需要在每个层次结构都执行虚拟调用。这通常会启用一个配置，使得一次方法调用可以产生多次虚拟调用，从而服务于过程中的多个类型。

要达到这个目的，你需要不止一个方法互相配合：每个分发都需要一个方法调用。以下示例（实现了一个“猜拳”游戏）中对应的方法是 compete() 和 eval()，它们都是相同类型的成员，会生成三个可能结果中的一个：

Outcome.java

public enum Outcome {WIN, LOSE, DRAW}

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

Item.java

public interface Item {
    Outcome compete(Item it);

    Outcome eval(Paper p);

    Outcome eval(Scissors s);

    Outcome eval(Rock r);
}

每个特定的Item都提供了这些方法的对应实现：

Paper.java

import static enums.TEST0005.Outcome.*;

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

Scissors.java

import static enums.TEST0005.Outcome.*;

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

Rock.java

import static enums.TEST0005.Outcome.*;

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() 幵始执行双路分发：

RoShamBo1.java

import java.util.Random;

public class RoShamBo1 {
    static final int SIZE = 20;
    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());
        }
    }
}

虚拟机制决定了 a 的类型，因此它在 a 的实际类型的 compete() 函数中唤醒。compete() 函数通过对剩余类型调用 eval() 方法，调用执行了第二次分发。将自身 (this) 作为参数传入 eval()，会产生一个对重载 eval() 的调用，由此保留了第一次分发的类型信息。当第二次分发结束后，你就知道了两个 Item 对象的准确类型。

构建多路分发需要很多道工序，但是记住它所带来的好处：在调用中保持了语法的优雅，而不是在调用中编写丑陋的代码来确定一个又一个的对象类型。你只需要说：“你们两个！我不关心你们是什么类型，你们自己处理好彼此的交互！”当然，在决定使用多路分发前，要确定这种优雅的语法确实对你很重要。