如何使同一类的两个对象相互通信?

我想让同一个类的两个对象"talk"给彼此。

我想做的描述，但不知道如何，我没有找到一个解决方案:

public class Player  {
boolean initiative;
static int counter;
Player () {
if (counter == 0) {
initiative = true;
} else { 
initiative = false;
}
counter++;
}

setInitiative (boolean switch){
//problem is here:
//if switch true, change all other objects to false
//if switch false do nothing (not the problem ;))
}
}
public class Main {
var player1 = new Player(); //constructs player1.initiative == true
var player2 = new Player(); //constructs player2.initiative == false
player2.setInitiative (true); //should change player1.initiative to false
System.out.print (player1.initiative);
}
Outputs>>> false

我的setInitiative方法应该是什么样子，才能给我结果呢?是否有一种方法可以同时与类的所有实例进行通信?

你的问题问如何链接同一类的两个实例，它还问如何链接同一类的所有实例。有几种方法可以做到这两点，所以我将建议一种简单的方法来做到这两点，然后稍微改变设计以简化。

链接两个实例

public class Main {
public static void main(String[] args) {
Player player1 = new Player();
Player player2 = new Player();
player2.setInitiative(true);
System.out.print (player1.initiative);
}
}
class Player  {
Player linkedPlayer;
boolean initiative;
static int counter;

Player () {
if (counter == 0) {
initiative = true;
} else { 
initiative = false;
}
counter++;
}

static void linkPlayers(Player a, Player b) {
a.linkedPlayer = b;
b.linkedPlayer = a;
}

void setInitiative (boolean newInitiative) {
initiative = newInitiative;
if (linkedPlayer != null) {
linkedPlayer.initiative = !newInitiative;
}
}
}

这有几个缺点:

实例必须在创建后被链接。

链接所有实例

我不知道如何发现一个类的所有实例，但你可以在创建它们时将它们添加到列表中。

import java.util.*;
public class Main {
public static void main(String[] args) {
Player player1 = new Player();
Player player2 = new Player();
Player player3 = new Player();
player2.takeInitiative();
System.out.println(player1.initiative);
System.out.println(player2.initiative);
System.out.println(player3.initiative);
}
}
class Player  {
private static List<Player> allPlayers = new ArrayList<>();

boolean initiative;

Player () {
initiative = allPlayers.isEmpty();
allPlayers.add(this);
}

void takeInitiative () {
for (Player p : allPlayers) {
p.initiative = false;
}
initiative = true;
}
}

我已经更改了set Initiative方法。在超过两名玩家的情况下，不清楚当一名玩家失去主动权时会发生什么。是别人得到了，还是没人得到。

代码可能看起来更干净，但实际上，静态列表存在重大的设计问题:

它阻止你的程序容易包含一组以上的玩家(可能在同一时间运行多个游戏)。
它防止任何播放器被垃圾收集器清理，因为列表将始终有一个引用。你可以用某种弱引用来缓解这个问题，但我更愿意解决设计问题。

让我们将所有聪明的逻辑从player类中取出，并将其放入游戏类中。

import java.util.*;
public class Game {
public static void main(String[] args) {
Player player1, player2, player3;

List<Player> allPlayers = new ArrayList<>();
allPlayers.add(player1 = new Player(true));
allPlayers.add(player2 = new Player(false));
allPlayers.add(player3 = new Player(false));
assignInitiative(player2, allPlayers);
System.out.println(player1.initiative);
System.out.println(player2.initiative);
System.out.println(player3.initiative);
}

static void assignInitiative(Player takingInitiative, List<Player> allPlayers) {
for (Player p : allPlayers) {
p.setInitiative(false);
}
takingInitiative.setInitiative(true);
}
}
class Player  {
boolean initiative;

Player (boolean initiative) {
this.initiative = initiative;
}

void setInitiative (boolean newInitiative) {
initiative = newInitiative;
}
}

在这里，玩家通过游戏类链接。你保留了所有的功能，但现在你可以在同一个程序中有多个游戏，并修复了内存泄漏。

但是由于逻辑已经转移到游戏类中，您可以使用一个变量进一步简化以保持玩家的主动性。

public class Game {
public static void main(String[] args) {
Player player1 = new Player();
Player player2 = new Player();
Player player3 = new Player();

Player initiativeHolder = player2;
System.out.println(player1 == initiativeHolder);
System.out.println(player2 == initiativeHolder);
System.out.println(player3 == initiativeHolder);
}
}
class Player  {
}

相关内容

最新更新

热门标签：