Question

我有2个类，并且已经使一个类（A类）实例化了B类对象。

我在B类中有一个方法要在A类中调用一个方法。

我正在研究一个更大的Java实践项目，所以我在这里简化了事情。

// A类：

public class ClassA {
  private int number;
  private ClassB instanceOfB = new ClassB();

  public ClassA {
    number = 0;
  }

  public void incrementNumber {
    number++;
  }

  public void incrementNumberLongWay {
    instanceOfB.incrementNumberInA()
  }
}

// B类：

public class ClassB {
  public void incrementNumberInA() {
    // My desire: Call Class A's incrementNumber method
    // What should I put here?
   }

}

我如何确保crementNumberLongWay有效？类A已被实例化，它的方法incrementNumberLongWay已被调用，因此应调用类B的方法incrementNumberInA

我知道这似乎非常令人费解，但是我这样做的原因是因为在我的程序中我没有增加数字，而是在B类中进行了一些逻辑运算，并且只想在某些情况下影响A类

Answer 1

您不能使用提供的代码来执行此操作。关系默认是一种方式。 B不了解A，因此无法访问它。

您可以做的是在构建过程中将A的引用传递给B，然后通过该引用访问A。

Answer 2

ClassB对ClassA一无所知。所以，你做不到。丑陋的决定是

public void incrementNumberLongWay() {
        instanceOfB.incrementNumberInA(this);
    }

和

public class ClassB {
    public void incrementNumberInA(ClassA cl) {
        cl.incrementNumber();
    }
}

Answer 3

您不能从类B调用类A的方法，因为类B没有引用类a的对象。但是，您可以将A类的当前数字状态作为参数传递给B类，然后从B类返回一个值，然后A类可以获取和使用该值。

例如：

public class A {
    private int number;
    public A(int number) {
        this.number = number;
    }
    public void incrementNumber(boolean largeIncrement) {
        if(largeIncrement) {
            B bInstance = new this.B();
            number = bInstance.incrementNumberLongWay(number);
        }
        else {
            number++;
        }
    }
    private class B {
        private B() {
            // if some initialization is needed...
        }
        public int incrementNumberLongWay(int num) {
            num += 1000;
            return num;
        }
    }
}

希望这就是您想要的。

Answer 4

一种解决方案是将A方法作为回调。

例如：

public class ClassA {
  private int number;
  private ClassB instanceOfB = new ClassB();

  public ClassA {
    number = 0;
  }

  public void incrementNumber {
    number++;
  }

  public void incrementNumberLongWay {
    instanceOfB.incrementNumberInA(this::increment);
    // alternatively
    // instanceOfB.incrementNumberInA(() -> incrementNumber());
  }
} 

public class ClassB {
  public void incrementNumberInA(Runnable callbackMethod) {
    callbackMethod.run();
  }
}

这消除了B对A的依赖，而是允许了一种通用的回调机制。

但是，对于这种简单的情况，不建议采用这种方法。

Answer 5

以这种方式具有循环依赖关系通常可能是一个坏主意。打破周期的一种方法是让第三类（classC？）实现增量逻辑（或与您的实际等效的任何东西），并让classA和classB实例各自引用classC。这样，就不会有两个类彼此了解的情况。

A类实例化B类实例。 ClassB的实例如何调用A类的方法？

5 个答案: