使用多个类。程序不会启动

Question

我一直在处理一个相当大的程序，并认为是时候拆分我的课程了。 1 个用于 GUI 代码的 .java 文件，以及 1 个用于 GUI 呈现的功能背后的机制的 .java 文件。但这是我的问题，我在彼此内部创建了每个类的实例，然后程序拒绝启动，所以我显然做错了什么。在我的RPG 类中，我有以下代码行：

public Mechanics mechanics = new Mechanics();

对于我的Mechanics 课程，我有这个代码：

public RPG rpg = new RPG();

我这样做的原因是为了尝试这个： 我的很多变量都在RPG 类中，我希望能够从我的rpg 调用它们并对其进行操作，然后将它们发送回RPG 这是我用来测试这个函数的代码（来自我的Mechanics 班级）：

class Mechanics{
public RPG rpg = new RPG();
  public Mechanics(){
  }
  public void helloWorld(){
    System.out.println("Hello World!");
    System.out.println("Health before:"+rpg.Health);
    rpg.Health = rpg.Health - 5;
    System.out.println("Health after:"+rpg.Health);
  }
 }

是的，Health 是我的 RPG 类中的公共 int。

在我的RPG 课程中，这是我用来测试我的Mechanics 课程的代码：

mechanics.helloWorld();

这是我的问题：代码可以编译，但是当我尝试运行它时，我得到了这个错误：

 at Mechanics.<init>(Mechanics.java:15)
 at RPG.<init>(RPG.java:127)

这是我的问题。我这样做对吗？我的代码有什么问题导致我的程序不想运行？

添加：我也尝试将我的其他类称为private，程序将编译，但仍然拒绝启动，并给我同样的错误

Mechanics 的第 15 行：

public RPG rpg = new RPG();

RPG 的第 127 行：

public Mechanics mechanics = new Mechanics();

Answer 1

这是因为您在 RPG 类中实例化了一个新的 Mechanics 类。然后在Mechanics 类中实例化一个新的RPG 类。

结果是无限循环的实例化。

对于您的具体示例，我个人认为解决问题的最佳方法是将 RPG 实例直接传递给 hello world 方法。

class Mechanics {
    public void helloWorld(RPG rpg) {
        ...
    }
}

然后在你的 RPG 类中看起来像这样：

class RPG {
    // passing a mechanics object in via the constructor would be better than hard-coding it here
    public Mechanics mechanics = new Mechanics();

    public int Health = 100;
    ...

    public void someMethod() {
        mechanics.helloWorld(this); // pass in the rpg instance
    }
}

Answer 2

Mechanics 的第 15 行可能更像：

public RPG rpg = new RPG(this); // must be in constructor or non static method

在 RPG 中：

public Mechanics mechanics;

在构造函数中：

this.mechanics = mechanics;

Answer 3

在初始化 RPG 或 Mechanics 的实例时会产生无限循环。面向对象编程意味着关注点分离和低耦合。更改您的类依赖项，以便其中只有一个需要另一个。

Answer 4

“我已经在彼此内部创建了每个类的实例”

这是你的问题，最终结果是这样的：

A 类被构造，它里面有一个 B 类，它创建了一个新的 B 类
构造了 B 类，其中有一个 A 类，它创建了一个新的 A 类
构造了 A 类，其中有一个 B 类，它创建了一个新的 B 类
构造了 B 类，其中有一个 A 类，它创建了一个新的 A 类
构造了 A 类，其中有一个 B 类，它创建了一个新的 B 类
构造了 B 类，其中有一个 A 类，它创建了一个新的 A 类

等等等等，越来越深，直到你的程序崩溃。

class A 有一个 reference 到 class B 和 class B 有一个 reference 到 class A 没有任何（可怕）错误（尽管它可能没有是理想的），但是 class A 封装 class B 和 class B 封装 class A 有一些可怕的错误。如果两者都相互引用，那么对一个或两个的引用将被传递到一个或两个的构造函数中，因此不使用 new 关键字（但如果可能，请避免这样做）。

我经常（内疚地）使用的一个例子如下：

public class OwnerClass {
    SubordinateClass subOrdinate;

    public OwnerClass(){
        subOrdinate=new SubordinateClass(this);
    }

}

public class SubordinateClass {
    OwnerClass owner;

    public SubordinateClass(OwnerClass owner){
        this.owner=owner;
    }
}

免责声明：我并不是将此作为一种好的做法，但假设 A 类必须与 B 类对话，反之亦然，那么这就实现了