Java 如果调用了一个抽象方法，是什么决定了调用它的哪个实现方法？

结果是每次在

A

中发生该事件时，调用

B

的

foo（）

方法，而不是类

C

中的方法

我原以为

foo（）

会在

B

和

C

中被调用。为什么会发生这种情况？有什么更好的设计模式可以解决我的问题

---

更新：

我无法展示更多的代码，因为它非常复杂，有许多异步进程

B

和

C

是运行在不同线程中的可运行程序，可扩展

A

以使用其受保护的静态实用程序方法。

A

中有一个事件监听器，当另一个系统发送我想在

C

中处理的数据时调用该监听器

更新2:

我发现了一个错误，它回答了问题，使问题变得无关紧要，对不起。

---

在抽象类中，我使用了一个单例实例来创建事件处理程序。类

B

的线程首先创建，当它第一次调用这个构造函数时，它将抽象方法绑定到它自己的实现上，以后不会改变。

分配给引用的具体实例决定了这一点。

分配给引用的具体实例决定了这一点。

请共享包含调用的部分的代码正在调用实例的实际运行时类型上的方法。由于

A

是抽象的，因此类型必须是

B

或

C

。。。。为什么？如果创建

C

的实例，则

B

与此无关；如果创建

B

的实例，则

C

与此无关。如果您有

类B扩展C

，您可能会有疑问。。。但是，如果

B

重写了该方法，那么它就会被重写；或A obj2=新B（）；显然是别处的一个bug。从一个复制错误

System.out.println（“in B”）在
C.foo
中指向任何对象。另外，请先使用干净的重新生成项目。请共享包含方法调用部分的代码。正在调用实例的实际运行时类型上的方法。由于
A
是抽象的，因此类型必须是
B
或
C
。。。。为什么？如果创建
C
的实例，则
B
与此无关；如果创建
B
的实例，则
C
与此无关。如果您有
类B扩展C
，您可能会有疑问。。。但是，如果
B
重写了该方法，那么它就会被重写；或A obj2=新B（）；显然是别处的一个bug。从一个复制错误
System.out.println（“in B”）在
C.foo
中指向任何对象。还可以先用干净的文件重建项目。
abstract class A {

  // Here is an event listener that is called when an event occurs.
  // However, this event I don't want to process here but in class C.
  ...
    foo(processMe);
  ...

  // So using this abstract method I'm trying to delegate it to class C.
  public abstract void foo(String processMe);

}

class C extends A {

  // This is the method in which I'd like to handle the event,
  @Override
  public void foo(String processMe) { ... processing processMe ... }

  // ...but I have another class, class B that "steals the implementation".

}

// B extends A because there are many things B uses and implements from A.
class B extends A {

  // This method is completely unnecessary, it just has to be here as
  // abstract methods must be implemented in all extending subclasses.
  @Override
  public void foo(String processMe) { /* NOOP */ }

}

A a1 = new C(); 
a1.foo(); // execute foo() in C class

A a2 = new B(); 
a2.foo(); // execute foo() in B class