如果java中的方法在一个组合中，如何从另一个类正确地调用它们？

为了澄清这个问题，我用一个例子来说明

我有一个名为Player的简单类，它包含三个数据成员（“attack”，这在这里很重要），并为它们提供了setter和getter。（只有setAttack（）现在才重要）。 我有一个“Team”类，它将包含三个Player对象，以便 在球员场地上的操作。此外，Team类还有一个名为increaseattack（）的简单方法，它将使特定玩家的攻击增加1。（立即 通过其构造函数创建团队对象时调用）。 在Match类中，我创建了3个玩家对象，并由这些玩家对象创建了一个团队对象。现在有趣的事情开始了：在团队类中为指定的玩家调用setAttack（）也将改变最初创建的玩家在Match类中的攻击

我知道我在一些基本概念上是错的，但不知道如何正确地做到这一点。你能给我解释一下，为什么这样工作？ 以下是三个类的来源：

public class Player {
  String name;
  int attack;
  int defense;

public Player(String name, int attack, int defense){
    this.name = name;
    this.attack = attack;
    this.defense = defense;
}

public int getAttack() {
    return attack;
}
public void setAttack(int attack) {
    this.attack = attack;
}
public int getDefense() {
    return defense;
}
public void setDefense(int defense) {
    this.defense = defense;
}
}


public class Team {
   private Player player1;
   private Player player2;
   private Player player3;

public Team(Player p1, Player p2, Player p3){
    this.player1 = p1;
    this.player2 = p2;
    this.player3 = p3;
    increaseattack(player1);
}

public void increaseattack(Player pla){
    pla.setAttack(pla.getAttack()+1);
}

}


public class Match {
 Player player, player2, player3;
 Team team, team1;
//static Player player, player2, player3;
//static Team team, team1;

public static void main(String[] args){
    new Match();
}

public Match(){
    test();
}


public void test() {
    player = new Player("Alan", 10, 10);
    player2 = new Player("Bob", 10, 12);
    player3 = new Player("Cedric", 13, 10);
    team = new Team(player,player2,player3);  // Creating the team instance based on player instances created here, OK 10+1 = 11
    team1 = new Team(player,player2,player3);  // new team, hopefully i get the same results, but thats not the case, 11 is base attack, not 10!!!
    System.out.println("------------------------");
    System.out.println(" " + player.getName() + " " + player.getAttack() + " " + player.getDefense());
    System.out.println(" " + player2.getName() + " " + player2.getAttack() + " " + player2.getDefense());
    System.out.println(" " + player3.getName() + " " + player3.getAttack() + " " + player3.getDefense());


}

}

以下是输出：

------------------------
Alan 12 10
Bob 10 12
Cedric 13 10

这对我来说是不正确的，正如我所预料的那样，艾伦最初的攻击没有改变，只是“在”队里。谢谢你的帮助。谢谢。

不要这样做：

public void increaseattack(Player pla){
    pla.setAttack(pla.getAttack()+1);
}

在PLayer类中定义一个方法并直接执行操作

public void increaseAttack() {
    this.attack++;
}

而不是这样做：

public void increaseattack(Player pla){
    pla.setAttack(pla.getAttack()+1);
}

在PLayer类中定义一个方法并直接执行操作

public void increaseAttack() {
    this.attack++;
}

---

你应该再看一遍你的程序。 您的团队构造函数正在第一个参数中添加“攻击”

public Team(Player p1, Player p2, Player p3){
this.player1 = p1;
//this.player2 = p2;
//this.player3 = p3;
increaseattack(player1);

---

这就是Alans攻击增加的原因。

您应该重新检查您的程序。 您的团队构造函数正在第一个参数中添加“攻击”

public Team(Player p1, Player p2, Player p3){
this.player1 = p1;
//this.player2 = p2;
//this.player3 = p3;
increaseattack(player1);

---

这就是阿兰斯攻击增加的原因。

你创造了一个攻击为10的玩家：

player = new Player("Alan", 10, 10);

然后将该玩家添加到两个团队：

team = new Team(player,player2,player3);
team1 = new Team(player,player2,player3);

团队的构造函数中发生了什么

this.player1 = p1;
//...
increaseattack(player1);

increaseattack（）
做什么

pla.setAttack(pla.getAttack()+1);

因此，
Alan
的攻击值从原来的10变为新的12，因为最后一次操作是对它执行两次，每增加一个团队执行一次


编辑：根据您在下面的评论，听起来您想做的不是询问球员的攻击是什么，而是询问球队对给定球员的攻击是什么。这是因为“第一”玩家的“攻击修饰符”是团队数据元素，而不是玩家数据元素

因此，在
团队
课程中，您可能会遇到以下情况：

public int getAttackFor(Player player) {
    if (player == player1) {
        return player.getAttack() + 1;
    }
    if ((player == player2) || (player == player3)) {
        return player.getAttack();
    }
    // throw an exception if the player isn't found?
}

这只是一个简单的想法，你可以根据自己的需要进行调整。可能基于玩家标识符进行比较，而不是直接的对象引用比较，可能将玩家放入数组中，而不是与单个变量进行比较，等等。但想法是：

提供一名
球员
，并要求该球员为该队发起进攻（因为这显然与球员单独的进攻有潜在的不同）
确定该
玩家是否招致“修改”攻击

为该队的
玩家
返回攻击
因此，要使用它，您需要在
main（）
中执行以下操作：

你创造了一个攻击力为10的玩家：

player = new Player("Alan", 10, 10);

然后将该玩家添加到两个团队：

team = new Team(player,player2,player3);
team1 = new Team(player,player2,player3);

团队的构造函数中发生了什么

this.player1 = p1;
//...
increaseattack(player1);

increaseattack（）
做什么

pla.setAttack(pla.getAttack()+1);

因此，
Alan
的攻击值从原来的10变为新的12，因为最后一次操作是对它执行两次，每增加一个团队执行一次


编辑：根据您在下面的评论，听起来您想做的不是询问球员的攻击是什么，而是询问球队对给定球员的攻击是什么。这是因为“第一”玩家的“攻击修饰符”是团队数据元素，而不是玩家数据元素

因此，在
团队
课程中，您可能会遇到以下情况：

public int getAttackFor(Player player) {
    if (player == player1) {
        return player.getAttack() + 1;
    }
    if ((player == player2) || (player == player3)) {
        return player.getAttack();
    }
    // throw an exception if the player isn't found?
}

这只是一个简单的想法，你可以根据自己的需要进行调整。可能基于玩家标识符进行比较，而不是直接的对象引用比较，可能将玩家放入数组中，而不是与单个变量进行比较，等等。但想法是：

提供一名
球员
，并要求该球员为该队发起进攻（因为这显然与球员单独的进攻有潜在的不同）
确定该
玩家是否招致“修改”攻击

为该队的
玩家
返回攻击
因此，要使用它，您需要在
main（）
中执行以下操作：

通过test（）方法，您可以使用指定的值创建三个Player对象

然后通过这三个玩家对象创建一个团队对象

团队对象的player变量指向原始player对象。（您只是使用不同的变量名来引用相同的对象）

所以，团队对象可以更改属于玩家对象的成员的值。
就你而言：

"Alan", 10, 10
"Bob", 10, 12
"Cedric", 13, 10

对于团队对象，将Alan的攻击值更改为11

因此，新的价值观是：

"Alan", 11, 10
"Bob", 10, 12
"Cedric", 13, 10

"Alan", 12, 10
"Bob", 10, 12
"Cedric", 13, 10

然后创建另一个团队对象“team1”，通过这些相同的玩家对象。
艾伦的攻击值再次增加。因此，新值为：

"Alan", 11, 10
"Bob", 10, 12
"Cedric", 13, 10

"Alan", 12, 10
"Bob", 10, 12
"Cedric", 13, 10

因此，您的输出

阅读本文了解更多信息：
通过test（）方法，您可以使用指定的值创建三个Player对象

然后通过这三个玩家对象创建一个团队对象

团队对象的player变量指向原始player对象。（您只是使用不同的变量名来引用相同的对象）

所以，团队对象可以更改属于玩家对象的成员的值。
就你而言：

"Alan", 10, 10
"Bob", 10, 12
"Cedric", 13, 10

对于团队对象，更改Alan的攻击t的值