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

Question

我想让同一类的两个对象互相“交谈”。

我想按照描述的做，但不知道怎么做，我没有找到解决方案：

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 方法必须如何查看才能给出我的结果？ 有没有办法一次与一个类的所有实例进行通信？

Answer 1

您的问题询问如何链接同一类的两个实例，还询问如何链接同一类的所有实例。有几种方法可以实现这两种方法，因此我将建议一种简单的方法来实现每种方法，然后稍微更改设计以简化。

链接两个实例

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

我更改了设置主动方法。如果有两个以上的玩家，当一个玩家失去主动权时会发生什么还不清楚。别人得到它，还是没有人得到它。

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

• 它会阻止您的程序轻松包含一组以上的玩家（可能同时运行多个游戏）。
• 它可以防止任何玩家被垃圾收集器清理，因为列表将始终具有引用。您可以通过某种弱参考来缓解这种情况，但我更愿意解决设计问题。

让我们从玩家类中取出所有巧妙的逻辑，并将其放入游戏类中。

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