Question

我是一个完整的java /编程初学者，我正在尝试制作一个基本的格斗游戏。作为该目标的一部分，我正在努力学习面向对象。

我创建了一个播放器类，它当前有一些变量（att，str等，命中点），并且我正在尝试制作一个strike（）方法。此方法应从两个玩家获取数据，并对1个玩家对象的生命值变量执行基本计算。

我认为strike（）方法应该将两个玩家对象（我在main方法中定义）作为输入，并在正文代码中指定每个玩家的变量，但我不知道如何做到这一点。

代码：

public class Player {

  String name;
  int hitpoints = 250;
  int str = 10;
  int att = 10;
  int def = 10;

  public void strike(Player player)
  {
      hitpoints = hitpoints - str * att / def;
  }

}

感谢您阅读此内容。如果有人能指出我正确的方向，我将非常感激。

Answer 1

您的方法只需要将一个播放器作为输入参数。如果你没有使它成为static，那么一个方法已经属于一个对象（一个Player），所以你只需要提供另一个Player作为参数。

public void strike(Player otherPlayer)
{
   otherPlayer.setHitpoints(otherPlayer.getHitpoints() - str * att / def);
}

请注意，您需要定义getHitpoints和setHitpoints来访问其他Player对象的生命值，但这是一种常见的Java约定。 str，att和def变量都隐含地引用了当前（this）播放器的那些属性。

然后你这样称呼它，所以一个玩家攻击另一个玩家。

Player a = new Player();
Player b = new Player();
a.strike(b);

Answer 2

作为该目标的一部分，我正在尝试学习面向对象。

实际上，你是以程序方式推理的。

我认为strike（）方法应该采用两个玩家对象

你不认为strike()应该是一个实例方法吗？

当您编写myPlayer.strike(...)时，myPlayer变量引用的对象将触发另一个Player对象。
所以使用方法实例是有道理的保持实际定义的方法，但没有static修饰符。

除了计算生命值之外，还应该是Player实例方法，例如：computeHitPoints()。

你可以写：

public void strike(Player otherPlayer){
      otherPlayer.hitpoints -= this.computeHitPoints();
      ...
}

public double computeHitPoints(){
  return str * att / def;
}

Answer 3

正如litelite的评论中指出的那样，你的班级应该以一个大写的方式开始播放。

然后你的函数应该获取一个玩家对象并改变该对象的属性。

public void Strike(Player player){
   player.hitpoints = player.hitpoints - (str * att) / def;
}

我建议你遵循这种模式。

Answer 4

是的，这种方法可行，但是，这个类不应该是＆＃34;硬编码＆＃34;就像现在一样。由于str，att和def总是为10，因此命中点将设置为0.您的构造函数应该获取str，att和def的值，然后在构造函数中初始化这些字段。此外，您可以更改的一个小问题是使用 - =运算符。你在strike方法中所拥有的是正确的（虽然我不会让它变为静态）但你可以这样写它：

hitpoints - =（str * att）/ def

Answer 5

不确定我是否理解这个问题，但您是否尝试过这样做？

 public static void strike(player player1, player player2)
 {
  hitpoints = hitpoints - str * att / def;
 }

请注意帖子评论中的ClassName提示，不要在这里使用静态方法

Answer 6

如评论中所述，您的班级名称应以大写字母开头。您可以像这样编写静态方法：

public static void strike(Player player1, Player player2)
  {
     player1.hitpoints = ... //access to variable 'hitpoints' of player1
     player2.hitpoints = ... //access to variable 'hitpoints' of player2
     int example = player2.hitpoints - player1.hitpoints; //kind of calcul you can do 
                                                          //with the use of your two players
  }

Answer 7

如果我理解这个问题，你应该在播放器类中编写一个方法来获取属性或返回一个副本（Getter / Producer）并执行计算，另一个方法更新播放器的内部状态（Setter）。我也会将属性设为私有。

Answer 8

考虑一下这里发生了什么。一个Player引人注目。另一个被击中。我会为这两部分实现单独的方法：

public class Player {

  String name;
  private int hitPoints = 250;
  private int str = 10;
  private int att = 10;
  private int def = 10;

  public void strike(Player other){
    other.receiveStrike(str * att);
  }

  private void receiveStrike(int strikePower){
    int hitPoints = hitPoints - computeDamage(strikePower);
  }

  protected int computeDamage(int strikePower){
    return strikePower / this.def;
  }

  public static void main(String[] args){

    Player one = new Player();
    Player two = new Player();

    while (two.hitPoints > 0){
            one.strike(two);
            System.out.println("two's hitpoints: " + two.hitPoints);
    }
  }
}

所以strike方法只是告诉另一个Player它被击中的难度。 Player负责确定罢工造成的损害程度并适当更新其状态。

这里有几个关键点。首先，我没有真正添加您尚未编写的任何代码。我只是将它安排到方法中。其次，main中的示例代码从不调用receiveStrike方法。它只调用公共方法strike。另请注意，Player实例不直接触及它所攻击的播放器的hitPoints属性。另一个玩家在通过私有hitPoints方法攻击时修改自己的receiveStrike属性。该方法使用方法protected int computeDamage来确定罢工实际造成的伤害程度。这允许我们做这样的事情：

public class InvinciblePlayer extends Player {
  @Override
  protected int computeDamage(int strikePower){
    System.out.println("Mwa-ha-ha-ha!!! I am invincible!!! ... Almost");
    return 0;
  }
}

你可以点击InvinciblePlayer你想要的一切，它根本不会造成任何伤害。更一般地说，这允许不同Player类型的一系列防御能力。这就是拆分这样的方法的真正好处。攻击者确定攻击的强大程度，防御者确定其实际造成的伤害程度。

这只是你可以做的事情的冰山一角。我真的希望保持尽可能接近原始代码。下一步可能是创建类型Strike并将receiveStrike(int strikePower)更改为receiveStrike(Strike strike)。这可能会让玩家对Kick和Punch采取不同的反应，甚至反击某些攻击。现在这有点先进，但是一旦你掌握了这一点，就要考虑一下。

java：创建一个操作两个对象的方法（初学者）

8 个答案: