关于石头剪刀布的模拟程序（二路分发）

二路分发（java 编程思想中这么说的）。

还是没有理解，我对这个设计的理解就是将本应该instanceof实现的功能替换成使用多态来实现。

下面是两个版本，第一个是我使用instanceof的实现，第二个是java编程思想中使用多态的实现。

公共的结果枚举：

package test2;
public enum Outcome {
    WIN,LOSE,DRAW
}

我的实现（使用instanceof）：

package test2;
import static test2.Outcome.DRAW;
import static test2.Outcome.LOSE;
import static test2.Outcome.WIN;

import java.util.Random;
/**
 * 
 * 我自己的石头剪刀布实现
 *
 */
interface MyItem {
    Outcome compete(MyItem m ) ;
}
class MyPaper implements MyItem {
    @Override
    public Outcome compete(MyItem m) {
        if(m instanceof MyPaper ){
            return DRAW ;
        }
        if(m instanceof MyScissors ){
            return LOSE ;
        }
        if(m instanceof MyRock ){
            return WIN ;
        }
        return DRAW ;
    }
    @Override
    public String toString() {
        return "Paper" ;
    }
}
class MyScissors implements MyItem {
    @Override
    public Outcome compete(MyItem m) {
        if(m instanceof MyPaper ){
            return WIN ;
        }
        if(m instanceof MyScissors ){
            return DRAW ;
        }
        if(m instanceof MyRock ){
            return LOSE ;
        }
        return DRAW ;
    }
    @Override
    public String toString() {
        return "Scissors" ;
    }
}
class MyRock implements MyItem {
    @Override
    public Outcome compete(MyItem m) {
        if(m instanceof MyPaper ){
            return LOSE ;
        }
        if(m instanceof MyScissors ){
            return WIN ;
        }
        if(m instanceof MyRock ){
            return DRAW ;
        }
        return DRAW ;
    }
    @Override
    public String toString() {
        return "Rock" ;
    }
}
public class MyRoShamBo {
    private static Random random = new Random(47) ;
    /**
     * 随机产生输出
     * @return 输出对象 
     */
    public static MyItem randomItem(){
        int item = random.nextInt(3) ;
        switch(item){
        case 0 :
            return new MyPaper() ;
        case 1 :
            return new MyScissors() ;
        case 2 :
            return new MyRock() ;
        default :
            throw new RuntimeException("随机产生出现异常 ！") ;
        }
    }
    public static void main(String[] args) {
        for(int i = 0 ; i < 10 ; i ++){
            MyItem one = randomItem() ;
            MyItem two = randomItem() ;
            System.out.println(one + " : "  + two + " " + one.compete(two));
        }
    }
}

多态的实现：

package test2;
import static test2.Outcome.* ;

import java.util.Random;
interface Item {
    Outcome compete(Item i ) ;
    /**
     * 将当前对象与Paper进行比较 
     * @param p Paper对象 
     * @return 比较结果
     */
    Outcome eval(Paper p ) ;
    Outcome eval(Scissors s ) ;
    Outcome eval(Rock r ) ;
}
class Paper implements Item {
    @Override
    public Outcome compete(Item i) {
        /**
         * 现在考虑调用时的情形：
         * Item a = new Paper() ;
         * Item b = new Paper() ;
         * a.compete(b) ;
         * 当在a中执行complete方法时，this的类型已经确定，不是Item接口类型，而是具体实现类类型。
         * 但是传递进来的b已经被向上转型为Item类型，所以在使用this.eval(b)时会出现参数类型不匹配的问题。
         * 当使用b.eval(this)时就可以了，这时b通过多态的机制调用了适用于this的重载的eval方法。
         * java编程思想上说的是：
         * 将自身（this）作为参数调用eval（），能够调用重载过的eval（）方法，这能够保留第一次分发的类型信息。
         */
        return i.eval(this) ;
        //The method eval(Paper) in the type Paper is not applicable for the arguments (Item)
        //this.eval(i) ;
    }
    @Override
    public Outcome eval(Paper p) {
        return DRAW ;
    }
    @Override
    public Outcome eval(Rock r) {
        return WIN ;
    }
    @Override
    public Outcome eval(Scissors s) {
        return LOSE ;
    }
}
class Scissors implements Item {
    @Override
    public Outcome compete(Item i) {
        return i.eval(this) ;
    }
    @Override
    public Outcome eval(Paper p) {
        return WIN ;
    }
    @Override
    public Outcome eval(Rock r) {
        return LOSE ;
    }
    @Override
    public Outcome eval(Scissors s) {
        return DRAW ;
    }
}
class Rock implements Item {
    @Override
    public Outcome compete(Item i) {
        return i.eval(this) ;
    }
    @Override
    public Outcome eval(Paper p) {
        return LOSE ;
    }
    @Override
    public Outcome eval(Rock r) {
        return DRAW ;
    }
    @Override
    public Outcome eval(Scissors s) {
        return WIN ;
    }
}
public class RoShamBo {
    private static Random random = new Random(47) ;
    /**
     * 随机产生输出
     * @return 输出对象 
     */
    public static MyItem randomItem(){
        int item = random.nextInt(3) ;
        switch(item){
        case 0 :
            return new MyPaper() ;
        case 1 :
            return new MyScissors() ;
        case 2 :
            return new MyRock() ;
        default :
            throw new RuntimeException("随机产生出现异常 ！") ;
        }
    }
    public static void main(String[] args) {
        for(int i = 0 ; i < 10 ; i ++){
            MyItem one = randomItem() ;
            MyItem two = randomItem() ;
            System.out.println(one + " : "  + two + " " + one.compete(two));
        }
    }
}