如何使用随机构造函数比较两个对象

Question

我做了这两个对象：

Fighter Lucas = new Fighter(Statistics.punchStrength, 
Statistics.movementSpeed, Statistics.reflex);
Opponent Simon = new Opponent(Statistics.punchStrength2, 
Statistics.movementSpeed2, Statistics.reflex2);

我想通过比较他们的随机变量来让他们"战斗"，但我不知道该怎么做。

Answer 1

制作一个职业战斗机，然后制作 2 个实例 战士和对手 ...我不明白你为什么做 2 个做同样工作的班级。

Answer 2

你Fighter类应该有一个方法attack(Opponent)

class Figher{
// ..
public void attack(Opponent opponent){
int opponentMaxDamage = calculateHitpointsBy(opponent);
int damageByOpponent = opponent.defend(this, opponentMaxDamage);
this.lifePoints-=damageByOpponent;
}
public boolean isAlive(){
return 0< this.lifePoints;
}
// ..
}

并且您的对手类应该有一个方法defend(Fighter)

class Opponent{
// ..
public void defend(Figher fighter, int maxAttackDamage){
int myDamage = reduceDamage(fighter,int maxAttackDamage);
int attackerDamage = calculateAttackerDamage(fighter);
this.lifePoints-=myDamage ;
}
public boolean isAlive(){
return 0< this.lifePoints;
}
// ..
}

这使您可以在以后为生命点添加更复杂的计算。例如：攻击者对对手造成的实际伤害可能取决于她佩戴的装备。对手受到的伤害可能也是如此。

方法isAlive()可以提取到公共基类中...

您可以以这种方式使用它：

Fighter Lucas = new Fighter(Statistics.punchStrength, Statistics.movementSpeed, Statistics.reflex);
Opponent Simon = new Opponent(Statistics.punchStrength2, Statistics.movementSpeed2, Statistics.reflex2);
// fight
while(Lucas.isAlive()&&Simon.isAlive())
Lucas.attack(Simon);
// report winner
if(Lucas.isAlive())
System.out.println("winner is Lucas");
if(Simon.isAlive())
System.out.println("winner is Simon");

Answer 3

在两个类中使用getter和setter方法，即战士和对手 然后

你的战斗机职业看起来像这样

class Fighter{
private int punchStrength, movementSpeed, reflex;
public int getPunchStrength() {
return punchStrength;
}
public void setPunchStrength(int punchStrength) {
this.punchStrength = punchStrength;
}
public int getMovementSpeed() {
return movementSpeed;
}
public void setMovementSpeed(int movementSpeed) {
this.movementSpeed = movementSpeed;
}
public int getReflex() {
return reflex;
}
public void setReflex(int reflex) {
this.reflex = reflex;
}
public Fighter(int punchStrength, int movementSpeed, int reflex) {
this.punchStrength = punchStrength;
this.movementSpeed = movementSpeed;
this.reflex = reflex;
}

}

你的对手职业看起来像这样

class Opponent{
private int punchStrength, movementSpeed, reflex;
public int getPunchStrength() {
return punchStrength;
}
public void setPunchStrength(int punchStrength) {
this.punchStrength = punchStrength;
}
public int getMovementSpeed() {
return movementSpeed;
}
public void setMovementSpeed(int movementSpeed) {
this.movementSpeed = movementSpeed;
}
public int getReflex() {
return reflex;
}
public void setReflex(int reflex) {
this.reflex = reflex;
}
public Opponent(int punchStrength, int movementSpeed, int reflex) {
this.punchStrength = punchStrength;
this.movementSpeed = movementSpeed;
this.reflex = reflex;
}

}

现在在你的主课上：

Fighter Lucas = new Fighter (Statistics.punchStrength, 
Statistics.movementSpeed, Statistics.reflex);
Opponent Simon = new Opponent (Statistics.punchStrength2, 
Statistics.movementSpeed2, Statistics.reflex2);
int avgFighter = ((Lucas.getpunchStrength())+(Lucas.getmovementSpeed())+(Lucas.getreflex()))/3;
int avgOpponent = ((Opponent .getpunchStrength())+(Opponent .getmovementSpeed())+(Opponent .getreflex()))/3;
if(avgFighter > avgOpponent )
System.out.println("Fighter wins");
else if(avgFighter == avgOpponent)
System.out.println("Draw");
else
System.out.println("Fighter looses");

Answer 4

简短版本

创建一个类 -Fighter- 它具有fight(Fighter otherFighter)方法。在该方法中，解决争吵，以便fight()逻辑和Fighter实现不会泄漏到类之外。有关示例，请参见下文。

长版本

我要做的是放弃拥有Opponent和Fighter类的想法，如果他们在做同样的事情并具有相同的字段。相反，为什么不Fighter课呢？我的理解是，您的对象之间的唯一区别是它们具有不同的值 - 这并不一定意味着您需要属于不同的类。因此，除非Fighter可以对抗其他一些属性截然不同的实体，否则一个类就足够了。此外，如果您需要更多行为略有不同的字段或/和方法，您可以随时扩展类。

现在，确定谁将赢得战斗是一个相当有趣的问题，因为您可以通过多种方式做到这一点，其中一些比其他方式更易于维护。一方面，您可以在类外计算结果。但是，我不认为这是最好的方法。首先，这意味着您需要了解很多关于Fighter，以及战斗是如何运作的。想象一下，如果其他人使用你的代码并想要解决争吵。他/她是否能够轻松做到这一点，或者他/她必须咨询您？

在我看来，逻辑不应该泄露给外部，因为从长远来看，这将使您的代码更难维护。 例如，如果属性发生变化怎么办？如果要解决代码的多个位置的争吵，该怎么办？你打算创建一个唯一目的是解决战斗的职业吗？似乎有点奇怪。或者，更糟糕的是，您要复制粘贴代码吗？如果是这样，如果您需要更改结果的逻辑，您会怎么做？您确定可以调整复制粘贴的所有代码吗？这些是您应该积极思考的问题。

当我看到一个名为Fighter的类时，我立即想到的是，所代表的实体，嗯，战斗。如果它能自己解决战斗，那不是很好吗？放置代码不是合乎逻辑的地方吗？因此，我的解决方案是这样的：

public class Fighter {
private int speed;
private int reflex;
private int strength;
public Fighter(int speed, int reflex, int strength) {
this.speed = speed;
this.reflex = reflex;
this.strength = strength;
}
public String fight(Fighter otherFighter) {
int thisSum = speed + reflex + strength;
int thatSum = otherFighter.speed + otherFighter.reflex + otherFighter.strength;
int outcome = thisSum - thatSum;
if (outcome == 0) {
return "Draw";
} else if (outcome > 0) {
return "First fighter won";
} else {
return "Second fighter won";
}
}
}

请注意fight()方法。您将另一个Fighter实例传入其中，无需任何努力即可解决战斗。唯一需要注意的是，您需要一种方法来确定哪些属性"更高"并计算整体结果。当然，有很多方法可以做到这一点。为了清晰和易于使用，我使用了int。但是你可以使用任何你喜欢的东西，或者实现任何你想要的逻辑。无论如何，现在您可以使用一个方法调用来解决战斗。因此，类外的整个代码如下所示：

public class Main {
public static void main(String[] args) {
Fighter fighter = new Fighter(1, 2, 3);
Fighter opponent = new Fighter(4, 2, 1);
System.out.println(fighter.fight(opponent));
}
}

当然，fight()可以扩展为包含更复杂的逻辑。或者可以将其更改为接受一些常见的对手，怪物或战士的基础职业，这将使您不仅可以与Fighter战斗，还可以与其他实体作战。尽管如此，我会尝试实现的一件事是在Fighter类之外尽可能少地对战斗进行逻辑，这样如果我改变对战斗如何工作的想法，就不必在多个地方更改代码。

顺便说一下，我没有使用getter和setter，但如果获取属性涉及某种逻辑，这可能是一个好主意。