用于隐藏第三方类方法的 Java/模式

Question

我有一个 A 类，它有一系列处理程序，例如公共(public)无效handleEv1()，公共(public)无效handleEv2()等。 当事件发生时，B 类中的另一个线程从 A 类调用相应的处理程序(B 类具有对 A 类观察者-可观察对象的引用)。 在类A的相应方法中处理事件时，A最终向事件监听器(不是我创建的类C)引发了一个事件。 我的问题如下:是否有一种模式可以用来从充当事件监听器(不是由我实现)的类中“隐藏”A类的处理方法，并且仅对B类(其中B类)“可见/可访问”我实现)？

我正在编辑我原来的问题。 我有一个 Csystem 类，它有很多方法和我正在谈论的处理程序

public class Csystem()
{

   private AListener listener;//implements an event listener (the class C in my question)

//some methods here
 public void handleEventIncoming(Event e){
//Do some logic here
  listener.raiseEvent(e);
 }
 public void handleEventOutgoing(Event e); etc


}

CSystem 是一个类，本质上是我的代码的其他组件的其他开发人员的接口(interface)。其他一些开发人员将编写自己的 AListener 类(A 类)版本，并在其代码中使用 Csystem。每当某处发生事件(例如网络中的消息到达)时，B 类都会将该事件传递给 CSystem 的事件处理程序

public class Dispatch{
//This is class B
 private CSystem s;

 private void event_occured(Event e)
 {
    s.handleEventIncoming(e);
 }
}   

} 我的问题是 Dispatch 类(由我实现)和 AListener 类“看到”CSystem 的相同接口(interface)。我希望实现 AListener 的开发人员能够看到 CSystem 的不同 View 并“看到”并且能够仅使用公共(public)方法。我认为查看某人实际上无法使用的方法不是一个好主意(处理程序仅由调度程序使用才有意义)是否有一种模式可以实现此目的？

谢谢!

Answer 1

使用接口(interface)。 B 与 A 的关系仅通过 B 定义并 A 实现的接口(interface)实现。

所以从 B 的角度来看，它甚至没有导入 A，或者在编译时无法访问 A 的定义。

针对问题进行编辑。

我相信你有C级

预先存在的，无法由您更改，某些包 x.y 中的代码；

Class CEvent {
   // some event definition
};

Class C {
    public void callWhenitHappens(CEvent theEvent) {
       // do something
    }
}

--- 你编写的代码 ---

package p.q;
public Class A implements BEventInterface {

   public void bEventHappened( BEvent theBEvent ){
       // make a C event
       myC.callWhenitHappens(theCEvent);
   }

}

您担心的是任何人，甚至包括 C 都可以调用 bEventHappened() 方法。

我的感觉是您担心的是一个不太可能出现的问题。为什么有人会不厌其烦地创建一个 A 对象并这样做呢？然而，有一些可能性:

1).如果A和B在同一个包中，不要将A及其方法公开。只有 B 需要看到它们，因此在包范围内这将起作用。

2).匿名内部类。请注意，A ia 类没有公共(public)方法，因此 C 不能使用它，但 B 在它可以使用的匿名内部类上有公共(public)方法。

package p.q;

import p.q.B.BEvent;
import x.y.z.C.CEvent;
import x.y.z.C;

public class A  {

// anonymous class implementing required interface
private BListener myFacade = new BListener(){
    @Override
    public void listen(BEvent event) {
        bEventHappened(event);          
    }       
};

private B myB;
private C myC;

A() {
    myC = new C();
    myB = new B();
    myB.registerListener(myFacade);
}

private void bEventHappened( BEvent theBEvent ){
       myC.callWhenitHappens(myC.new CEvent() );
}
}

B 类和 C 类看起来像:

package p.q;

public class B {

public class BEvent {
    public String what;
}

private BListener myListener;

private void fireEvent(){
    myListener.listen(new BEvent());
}

public void registerListener(BListener listener){
    myListener = listener;
}

}

和

package x.y.z;

public class C {
public class CEvent {
    public String what;
}

public void callWhenitHappens(CEvent event){
    //e3c
}

}