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

二路分发（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));
}
}
}