Question

我一直在研究一个相当大的程序，并认为是时候拆分我的课了。 1。GUI文件用于GUI代码，1 .java文件用于GUI提供的功能背后的机制。但是这是我的问题，我已经在彼此内部创建了每个类的实例，然后程序拒绝启动，所以我显然做错了。在我的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是我int课程中的公开RPG。

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

mechanics.helloWorld();

这是我的问题：代码编译，但是当我尝试运行它时，我收到此错误：

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

enter image description here 这是我的问题。我甚至这样做了吗？我的代码是不是让我的程序不想运行？

ADDED：我已经尝试将我的其他类称为private，程序将编译，仍然拒绝启动，并向我提供相同的错误

Mechanics的第15行：

public RPG rpg = new RPG();

RPG的第127行：

public Mechanics mechanics = new Mechanics();

Answer 1

这是因为您在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
    }
}

Answer 2

Mechanics的第15行可能更像：

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

在角色扮演游戏中：

public Mechanics mechanics;

在构造函数中：

this.mechanics = mechanics;

Answer 3

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

Answer 4

＆＃34;我已经在彼此内部创建了每个班级的实例＆＃34;

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

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

等永远，越来越深，直到程序崩溃。

class A 引用 class B和class B 引用 class A没有（可怕）错误1}}（虽然它可能不太理想），但class A封装class B和class B封装class A存在严重错误。如果两者都引用了彼此，那么对一个或两个引用的引用将被传递到一个或两个构造函数中，从而不使用new关键字（尽管如此，尽管如此，请避免使用）。 / p>

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

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类对话，反之亦然，这样就可以实现

使用多个类。该计划将无法启动

4 个答案: