Question

我搜索了整个StackOverflow网站，我遇到的只是最近的一个回答，但不是在我的条件下工作。

如何在彼此中调用两个类的方法

First Class是Alpha并且调用Beta的函数

public Class Alpha
    {
       Beta obj;

   public Alpha()
   {
       obj = new Beta();
   }
   public void A()
   {
      print A;
      obj.B();
   }
}

第二类是Beta并且调用Alpha的函数

public Class Beta
{
   Alpha obj;

   public Beta()
   {
       obj = new Alpha();
   }
   public void B()
   {
      print B;
      obj.A()
   }
}

在Java / android中，它显示了StackOverflow异常。由于彼此的构造函数的递归调用。

如何避免此异常？

我有15个类，每个类都是循环链接的。

我需要使用父类吗？

或者我应该如何使用构造函数来避免StackOverflow异常？

Answer 1

您应该更改类Beta的定义，以打破两个类之间的循环链接并创建它们的实例。它可能有点像这样：

public class Beta {
   Alpha obj;

   public Beta() {
   }

   public void B() {
      print B;
      new Alpha().A();
   }
}

理想情况下，除非您想要访问其他类，否则不应创建其他类的实例。

Answer 2

这里有一个打破周期的建议：指定一个类作为父类，另一个类作为依赖类。

让Alpha负责：

public class Alpha {

   private Beta beta;

   public Alpha() {
       this.beta = new Beta(this);
   }
}

这里的孩子是Beta：

public class Beta {

   private Alpha alpha;

   public Beta(Alpha parent) {
       this.alpha = parent;
   }
}

没有更多的周期。

Answer 3

堆栈溢出很明显;它不仅仅是类定义是周期性的;构造函数是递归的。递归只是＆＃34;隐藏＆＃34;因为他们在不同的班级。对于任何递归，必须有一些限制条件来打破递归周期。如果不知道问题的细节 - 为什么你有这个周期性的定义 - 很难给出解决方案。这真的归结为代码架构的问题。我可以提出一些建议。

首先，我通常不喜欢循环定义。它会导致代码构建和端口出现混乱和问题。这可以通过使用接口来避免;也许是一个空的标记界面。然后，我将从构造函数中分配内部对象，并创建一个显式的set（）函数，以便调用者必须初始化这些：

public interface SomeInterface {  }

public class Alpha implements SomeInterface
{ 
   private SomeInterface obj; 
   public Alpha()
   {}

   public void setBeta (SomeInterface si)
   {
     obj = si;
   } 
}

public class Beta implements SomeInterface
{ 
  private SomeInterface obj;
  public Beta () 
  { }

  public void setAlpha ( SomeInterface si )
  {
    obj = si;
  }
}

在通话代码中，您将拥有

Alpha a = new Alpha();
a.setBeta ( new Beta() );

如何在每个Java中调用两个类的方法时避免stackoverflow

3 个答案: