多路分发

有的时候程序要处理多种类型的交互，如果只使用单向的绑定支持，那么程序会变得相当复杂。比如，有A，B，C三种种类型互相比较，抽象出来的算法a.compete(b)，可是a,b可以是A，B，C中的任意两种类型的互相比较，这就麻烦了。

java的动态绑定其实是一种单路分发，能动态确定a的类型，不能够动态绑定b的类型，传统的方法就是重载compete方法。代码繁琐，还有些丑。

多路分发是一种技巧，可以让代码优雅 :) ，用实现“锤子、剪刀、布”的程序为例子：

 

 

写道

import java.util.Random;

public class RoShamBo{
static Random rand = new Random(4);

public static void main(String[] args){
for(int i = 0; i < 10; i++){
Item a = nextItem();
Item b = nextItem();
System.out.println(a + " vs " + b + " : " + b.compete(a));
}

}

static Item nextItem(){
switch(rand.nextInt(3)){
default:
case 0: return new Rock();
case 1: return new Scissors();
case 2: return new Paper();
}
}
}

enum Result{
WIN, DRAW, LOSE;
}

interface Item{
Result compete(Item e);
Result eval(Paper p);
Result eval(Scissors s);
Result eval(Rock r);
}

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

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

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

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

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

}

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

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

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

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

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

class Paper implements Item{

@Override
public Result compete(Item e){
return e.eval(this);
}

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

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

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

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