另一个班级

Question

我试图尽可能简化我的困境。我有三个班级：

α

public class Alpha {
     public void DoSomethingAlpha() {
          cbeta.DoSomethingBeta()  //?
     }
}

β

public class Beta {
     public void DoSomethingBeta() {
          // Something
     }
}

主：

public class MainApp {
     public static void main(String[] args) {           
          Alpha cAlpha = new Alpha();   
          Beta cBeta = new Beta();
     }
}

我希望我没有过度简化它。我的问题是如何从Alpha中的方法访问cBeta.DoSomethingBeta（）？

Answer 1

你需要以某种方式给类Alpha一个cBeta的引用。有三种方法可以做到这一点。

1）在构造函数中为Alphas提供Beta。在Alpha类中写道：

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

并从main（）

调用cAlpha = new Alpha（cBeta）

2）给Alphas一个改变者，给他们一个beta。在Alpha类中写道：

public class Alpha {
   private Beta beta;
   public void setBeta (Beta newBeta) {
     this.beta = beta;
   }

并调用cAlpha = new Alpha（）; cAlpha.setBeta（测试版）;来自main（）或

3）有一个beta作为doSomethingAlpha的参数。在Alpha类中写道：

public void DoSomethingAlpha(Beta cBeta) {
      cbeta.DoSomethingBeta()
}

您使用哪种策略取决于一些事项。如果您希望每个Alpha都有一个Beta，请使用数字1.如果您只想让一些Alpha拥有Beta，但您希望它们无限期地保留其Betas，请使用数字2.如果您希望Alphas仅处理Betas当你调用doSomethingAlpha时，使用数字3.变量范围最初很复杂，但是当你掌握它时它会变得更容易。如果您还有其他问题，请与我们联系！

Answer 2

方法1：

如果方法DoSomethingBeta是静态的，则只需要调用：

Beta.DoSomethingBeta();

方法2：

如果Alpha从Beta扩展，您可以直接调用DoSomethingBeta（）。

public class Alpha extends Beta{
     public void DoSomethingAlpha() {
          DoSomethingBeta();  //?
     }
}

方法3：

或者，您需要访问Beta实例才能从中调用方法。

public class Alpha {
     public void DoSomethingAlpha() {
          Beta cbeta = new Beta();
          cbeta.DoSomethingBeta();  //?
     }
}

顺便说一下这是家庭作业吗？

Answer 3

您需要在Alpha类或其方法

中创建Beta类型的对象

就像你在Main Beta中所做的那样cBeta = new Beta（）;

如果要使用在Main中创建的变量，则必须通过使Alpha构造函数看起来像

将其解析为cAlpha作为参数

public class Alpha 
{

    Beta localInstance;

    public Alpha(Beta _beta)
    {
        localInstance = _beta;
    }


     public void DoSomethingAlpha() 
     {
          localInstance.DoSomethingAlpha();     
     }
}

Answer 4

也许你需要一些dependency injection

public class Alpha {

    private Beta cbeta;

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

    public void DoSomethingAlpha() {
        this.cbeta.DoSomethingBeta();
    }
}

然后

Alpha cAlpha = new Alpha(new Beta());

Answer 5

public class WeatherResponse {

private int cod;
private String base;
private Weather main;

public int getCod(){
    return this.cod;
}

public void setCod(int cod){
    this.cod = cod;
}

public String getBase(){
    return base;
}

public void setBase(String base){
    this.base = base;
}

public Weather getWeather() {
    return main;
}

// default constructor, getters and setters
}

另一个班级

public class Weather {

private int id;
private String main;
private String description;

public String getMain(){
    return main;
}

public void setMain(String main){
    this.main = main;
}

public String getDescription(){
    return description;
}

public void setDescription(String description){
    this.description = description;
}

// default constructor, getters and setters
}

//访问方法
//成功！

    Log.i("App", weatherResponse.getBase());
    Log.i("App", weatherResponse.getWeather().getMain());
    Log.i("App", weatherResponse.getWeather().getDescription());

Answer 6

我有另一个解决方案。如果Alpha和Beta是你唯一的额外类，那么为什么不用类的图像创建一个静态变量。

与Alpha类一样：

public class Alpha{
        public static Alpha alpha;
        public Alpha(){
                this.alpha = this;
}

现在您可以通过使用以下行来调用Beta类中的函数：

new Alpha();
Alpha.alpha.DoSomethingAlpha();

Java：如何从另一个类访问方法

6 个答案:

另一个班级