当你处理多个交互类型时,程序可能会变得相当混乱。举例来说,考虑一个解析并执行数学表达式的系统。里面可能包括 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 对象的准确类型。
构建多路分发需要很多道工序,但是记住它所带来的好处:在调用中保持了语法的优雅,而不是在调用中编写丑陋的代码来确定一个又一个的对象类型。你只需要说:“你们两个!我不关心你们是什么类型,你们自己处理好彼此的交互!”当然,在决定使用多路分发前,要确定这种优雅的语法确实对你很重要。