关于oop：需要帮助推断Java代码

Need help extrapolating Java code

如果任何人熟悉wirfs丽贝卡-布洛克，她发现有一块在这里Java代码的书题为对象设计：角色、责任和合作。

这是一个双调度率>应用特异性问题实施了游戏的岩石，纸，scissors我们需要写代码是否是determines一个对象的"节拍"。游戏有三个可能的结果是基于对象。相互作用的交叉数是一种产品的对象。CASE语句或交换机是由所有类型的数据这是被操纵的。酒店面向对象语言等价是基地在其行动的一些其他类的对象。在Java中，它看起来像这样这里是一块16页"Java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import java.util.*;
import java.lang.*;

public class Rock
{
public static void main(String args[])
{

}

public static boolean beats(GameObject object)
{
if (object.getClass.getName().equals("Rock"))
{
result = false;
}
else if (object.getClass.getName().equals("Paper"))
{
result = false;
}
else if(object.getClass.getName().equals("Scissors"))
{
result = true;
}
return result;
}

＝＝＝＞，这不是一个很好的解决方案。第一，接收机需要知道太多关于我们的论点。第二，有一个条件语句的嵌套在每个三类。如果新种对象可以被添加到游戏中，三类都会被修改。任何人可以与我如何得到这股"小于最优的代码工作在一阶到海上工作。她是一个可证明的方式，但我会想你。谢谢

我将从定义类rpsssystem和rpsobject开始。构建经典RPS游戏的代码如下：

1
2
3
4
5
6
7
8

RPSObject rock = new RPSObject("Rock");
RPSObject paper = new RPSObject("Paper");
RPSObject scissors = new RPSObject("Scissors");
RPSSystem classicRPS = new RPSSystem(rock, paper, scissors);
// new RPSSystem(Collection<RPSObject> objects) possible too
classicRPS.defineBeatsRule(rock, scissors);
classicRPS.defineBeatsRule(paper, rock);
classicRPS.defineBeatsRule(scissors, paper);

rpss系统将有一个方法

1	int fight(RPSObject a, RPSObject b)

。

当a赢时返回-1，当b赢时返回1，当结果未定义时返回0。内部rpsobject可以存储在一个列表中，beating规则可以存储在一个矩阵中(列和行与列表中对象的索引相匹配)。如果允许类似rpsobject的多个实例，则应相应地编写rpsobject的equals方法。

对于系统中的每个对象都有一个单独的类似乎有点复杂。

编辑：

完整课程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package rpsgame;

public final class RPSObject {
private final String name;

public RPSObject(String name) {
this.name = name;
}

public String getName() {
return name;
}

public String toString() {
return getName();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

package rpsgame;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public final class RPSSystem {

private final List<RPSObject> objects;
private final int[][] beatsRules;

public static final int WINS = 1;
public static final int TIE = 0;
public static final int LOSES = -1;

public RPSSystem(RPSObject... objects) {
this.objects = Arrays.asList(objects.clone());
this.beatsRules = new int[objects.length][objects.length];
}

void defineBeatsRule(RPSObject winner, RPSObject loser) {
if (winner.equals(loser)) throw new IllegalArgumentException();

int winnerIndex = getObjectIndex(winner);
int loserIndex = getObjectIndex(loser);

beatsRules[winnerIndex][loserIndex] = WINS;
beatsRules[loserIndex][winnerIndex] = LOSES;
}

public int fight(RPSObject a, RPSObject b) {
int aIndex = getObjectIndex(a);
int bIndex = getObjectIndex(b);

return beatsRules[aIndex][bIndex];
}

public List<RPSObject> getObjects() {
return Collections.unmodifiableList(objects);
}

private int getObjectIndex(RPSObject o) {
int index = objects.indexOf(o);
if (index < 0) throw new IllegalArgumentException();
return index;
}

// test
public static void main(String[] args) {

RPSSystem classicRPS = buildClassicRPS();

List<RPSObject> objects = classicRPS.getObjects();

for (RPSObject a: objects) {
for (RPSObject b: objects) {
int result = classicRPS.fight(a, b);
switch (result) {
case RPSSystem.WINS:
System.out.println(a +" beats" + b);
break;
case RPSSystem.TIE:
System.out.println(a +" vs" + b +" is tied");
break;
case RPSSystem.LOSES:
System.out.println(a +" loses against" + b);
break;
}
}
}
}

private static RPSSystem buildClassicRPS() {
RPSObject rock = new RPSObject("Rock");
RPSObject paper = new RPSObject("Paper");
RPSObject scissors = new RPSObject("Scissors");

RPSSystem classicRPS = new RPSSystem(rock, paper, scissors);

classicRPS.defineBeatsRule(rock, scissors);
classicRPS.defineBeatsRule(paper, rock);
classicRPS.defineBeatsRule(scissors, paper);
return classicRPS;
}
}

。

加上RPSSystem.EVERYONE_DIES和defineEveryoneDiesRule(...)就可以了

1
2
3
4
5

rps.add(atombomb);
rps.defineBeatsRule(atombomb, scissors);
rps.defineBeatsRule(atombomb, rock);
rps.defineBeatsRule(atombomb, paper);
rps.defineEveryoneDiesRule(atombomb, atombomb);

。

相关讨论

使用具有beats(RPSObj o)方法的枚举(RPSObj处理它，其中每个枚举元素都有一个Set传入，存储为beatset。然后，用beats(RPSObj o)方法可以实现return beatset.contains(o);的功能。单工：)

编辑：您实际上可以使用一个Enumset作为集合实现，它应该比其他集合实现更高效：)

相关讨论

我个人认为我只需要一个实用程序类，它包含"beats"方法。"beats"方法将两个gameobject对象作为参数。

这样我就可以通过两个物体(石头、纸或剪刀)来执行必要的逻辑。现在，如果您添加了一个新对象，除了实用程序类中的"beats"方法之外，您不会更改其他任何内容，从而使内容从主对象中进行封装。

Ryan的链接很好，它还包含一些处理这种情况的其他想法。

相关讨论

您可能想看看这个线程：

利用遗传和多态性解决一个常见的博弈问题

这似乎是同一个主题。

这就是我修复它的方法。我第一次做了一个名为gameobject的新接口，因为他们提到它！

1
2
3
4

public interface GameObject
{
public boolean beats(GameObject g);
}

这种类型并不存在，所以说它不会有那么好的效果。

以下是我对摇滚乐的新代码，其中包含对变化的评论：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import java.util.*;
import java.lang.*;

public class Rock implements GameObject //Need to be an instance of GameObject somehow!
{
public static void main(String args[])
{

}

public boolean beats(GameObject object) //This isn't static anymore
{
boolean result = false; //Need to declare and initialize result
if (((Object)object).getClass().getName().equals("Rock")) //getClass should have ()
{
result = false;
}
else if (object.getClass().getName().equals("Paper")) //getClass should have ()
{
result = false;
}
else if(object.getClass().getName().equals("Scissors")) //getClass should have ()
{
result = true;
}
return result;
}
}

号

编辑：你似乎在问如何修复代码，而不是更好的方法。我相信这对你来说是件好事。

相关讨论