短版

Question

我制作了这两个对象：

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

我想通过比较他们的随机变量让他们“战斗”，但我不知道如何做到这一点。

Answer 1

制作一个级别的战士，然后是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;
  }
  // ..
}

并且您的Opponent类应该有一个方法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方法，即Fighter和Opponent 然后

您的战斗机类看起来像这样

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;
    }


}

您的Opponent类看起来像这样

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，但如果获取属性涉及某种逻辑，那么这可能是一个好主意。

如何将两个对象与随机构造函数进行比较

4 个答案:

短版

长版