Java—如何使类1和类2都相互了解？ 我有一个程序在写作中间，用来模拟虫子寻找食物。简言之，我有一个网格（一个世界），其中有虫子、障碍物和不同能量值的食物。每只虫子都会朝各个方向看，在它的“可视距离”内找到最近的食物，并朝着它移动一个细胞，否则就会朝随机方向移动

我有三门课：

• 阿布格

• 世界

• 主要

ABug和AWorld显然包含用食物和障碍物填充网格、感知食物、移动bug等的所有方法，主类是创建世界的控制器，根据用户输入创建许多bug并将它们添加到世界中

我的问题是:

有没有更好的方法让bug知道它所在的世界，而世界也知道其中的bug，而不是将世界的引用传递给bug中需要它的每个函数

我目前在world类中有一个bug的arraylist，然后将2D数组传递到bug类中需要它的函数中

对不起，我解释得太长了，我不知道人们会想要多少细节，所以我只想说：）

---

感谢您的建议，您不必将每个Bug方法作为参数传递给World，也可以在Bug的构造函数中执行一次，并将其保存在ABug的变量字段中，如下所示：

大体上：

public static void main(String[] args){
    AWorld world = new AWorld(...);
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(..., world);
}

public static void main(String[] args){
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(...);
}

---

你也可以试试StackFlowed所说的，让世界成为单身汉：

在世界上：

private static AWorld instance;

private AWorld(){ } // private constructor for Singleton pattern

public static AWorld getInstance(){
    if(instance == null)
        instance = new AWorld();

    return instance;
}

大体上：

public static void main(String[] args){
    AWorld world = new AWorld(...);
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(..., world);
}

public static void main(String[] args){
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(...);
}

就我个人而言，我会选择单例模式，因为这就是它们的设计目的。这还可以确保在整个应用程序中只有一个AWorld实例。（如果您想在某个状态下创建多个世界，我建议使用第一种方法。）

编辑：

---

如果您希望通过在同一应用程序中使用多个AWorld来进行将来的调整，或者使用UnitTests，那么Singleton模式不是一个很好的主意，因为它一次只能处理一个AWorld实例，不管它是否是UnitTest。因此，在这种情况下，我推荐第一种选择，只需将AWorld对象发送给ABug的构造函数并保存在ABug中，而不是将其作为ABug的每个方法的参数发送。尽管如此，如果您永远不想使用UnitTests或进行调整（不建议这样做，但这取决于您），这里可以使用Singleton模式。

您也可以在Bug的构造函数中执行一次，并将其保存在ABug的变量字段中，而不是将每个Bug方法作为参数传递给World，如下所示：

大体上：

public static void main(String[] args){
    AWorld world = new AWorld(...);
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(..., world);
}

public static void main(String[] args){
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(...);
}

---

你也可以试试StackFlowed所说的，让世界成为单身汉：

在世界上：

private static AWorld instance;

private AWorld(){ } // private constructor for Singleton pattern

public static AWorld getInstance(){
    if(instance == null)
        instance = new AWorld();

    return instance;
}

大体上：

public static void main(String[] args){
    AWorld world = new AWorld(...);
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(..., world);
}

public static void main(String[] args){
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(...);
}

就我个人而言，我会选择单例模式，因为这就是它们的设计目的。这还可以确保在整个应用程序中只有一个AWorld实例。（如果您想在某个状态下创建多个世界，我建议使用第一种方法。）

编辑：

---

如果您希望通过在同一应用程序中使用多个AWorld来进行将来的调整，或者使用UnitTests，那么Singleton模式不是一个很好的主意，因为它一次只能处理一个AWorld实例，不管它是否是UnitTest。因此，在这种情况下，我推荐第一种选择，只需将AWorld对象发送给ABug的构造函数并保存在ABug中，而不是将其作为ABug的每个方法的参数发送。尽管如此，如果您永远不想使用UnitTests或进行调整（不建议这样做，但这取决于您），这里可以使用Singleton模式。

您也可以在Bug的构造函数中执行一次，并将其保存在ABug的变量字段中，而不是将每个Bug方法作为参数传递给World，如下所示：

大体上：

public static void main(String[] args){
    AWorld world = new AWorld(...);
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(..., world);
}

public static void main(String[] args){
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(...);
}

---

你也可以试试StackFlowed所说的，让世界成为单身汉：

在世界上：

private static AWorld instance;

private AWorld(){ } // private constructor for Singleton pattern

public static AWorld getInstance(){
    if(instance == null)
        instance = new AWorld();

    return instance;
}

大体上：

public static void main(String[] args){
    AWorld world = new AWorld(...);
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(..., world);
}

public static void main(String[] args){
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(...);
}

就我个人而言，我会选择单例模式，因为这就是它们的设计目的。这还可以确保在整个应用程序中只有一个AWorld实例。（如果您想在某个状态下创建多个世界，我建议使用第一种方法。）

编辑：

---

如果您希望通过在同一应用程序中使用多个AWorld来进行将来的调整，或者使用UnitTests，那么Singleton模式不是一个很好的主意，因为它一次只能处理一个AWorld实例，不管它是否是UnitTest。因此，在这种情况下，我推荐第一种选择，只需将AWorld对象发送给ABug的构造函数并保存在ABug中，而不是将其作为ABug的每个方法的参数发送。尽管如此，如果您永远不想使用UnitTests或进行调整（不建议这样做，但这取决于您），这里可以使用Singleton模式。

您也可以在Bug的构造函数中执行一次，并将其保存在ABug的变量字段中，而不是将每个Bug方法作为参数传递给World，如下所示：

大体上：

public static void main(String[] args){
    AWorld world = new AWorld(...);
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(..., world);
}

public static void main(String[] args){
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(...);
}

---

你也可以试试StackFlowed所说的，让世界成为单身汉：

在世界上：

private static AWorld instance;

private AWorld(){ } // private constructor for Singleton pattern

public static AWorld getInstance(){
    if(instance == null)
        instance = new AWorld();

    return instance;
}

大体上：

public static void main(String[] args){
    AWorld world = new AWorld(...);
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(..., world);
}

public static void main(String[] args){
    ABug[] bugs = new ABug[amount];
    for(int i = 0; i < amount; i++)
        bugs[0] = new ABug(...);
}

就我个人而言，我会选择单例模式，因为这就是它们的设计目的。这还可以确保在整个应用程序中只有一个AWorld实例。（如果您想在某个状态下创建多个世界，我建议使用第一种方法。）

编辑：

如果您希望通过在同一应用程序中使用多个AWorld来进行将来的调整，或者使用UnitTests，那么Singleton模式不是一个很好的主意，因为它一次只能处理一个AWorld实例，不管它是否是UnitTest。因此，在这种情况下，我推荐第一种选择，只需将AWorld对象发送给ABug的构造函数并保存在ABug中，而不是将其作为ABug的每个方法的参数发送。不过，如果你