4

我一直在做一个相当大的程序，并认为是时候分开我的课程了。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的公众号。intRPG

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

mechanics.helloWorld();

这是我的问题：代码可以编译，但是当我尝试运行它时，出现此错误：

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

在此处输入图像描述 这是我的问题。我这样做对吗？我的代码有什么问题导致我的程序不想运行？

补充：我也尝试过调用我的其他类private，程序将编译，但仍然拒绝启动，并给我同样的错误

第 15 行Mechanics：

public RPG rpg = new RPG();

第 127 行RPG：

public Mechanics mechanics = new Mechanics();
4

4 回答 4

5

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

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

对于您的具体示例，我个人认为解决该问题的最佳方法是将 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
    }
}
于 2013-05-21T10:26:32.857 回答
4

第 15 行Mechanics可能更像：

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

在角色扮演游戏中：

public Mechanics mechanics;

在构造函数中：

this.mechanics = mechanics;
于 2013-05-21T10:32:01.840 回答
2

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

于 2013-05-21T10:26:53.017 回答
1

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

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

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

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

引用和引用到没有什么（可怕class A的）错误（尽管它可能并不理想），但是封装和封装有一些可怕的错误。如果两者都相互引用，那么对一个或两个的引用将被传递给一个或两个的构造函数，从而不使用关键字（即使可能，也要避免这种情况）。class Bclass Bclass Aclass Aclass Bclass Bclass Anew

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

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 类交谈，反之亦然，那么这就实现了

于 2013-05-21T10:27:20.020 回答