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

Question

我有一个A类，有一系列处理程序，例如public void handleEv1（），public void handleEv2（）等 当一个事件发生时，类B中的另一个线程，调用A类的通信者处理程序（B类具有对A类观察者可观察类的引用）。 在A类的相应方法中处理事件时，A最终将事件引发至eventListener（不由我创建的类C）。 我的问题是：是否有一种模式可以用来将类A的处理方法从作为事件监听器的类中“隐藏”（不是由我来实现），并且只对类B“可见/可访问”我执行）？

我正在编辑我的原始问题。 ，有很多的方法和处理我所说的

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我有类Csystem是一个类，基本上是其他组件的其他开发者我的代码的接口。其他一些开发人员将编写他自己版本的AListener类（A类），并在他的代码中使用Csystem。每当一个事件的某处发生（如网络中的消息到达），B级将事件传递给CSystem

的事件处理程序

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

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

} 我的问题是，无论是类分（通过我实现）和类AListener “看到”CSystem的相同界面。我希望实现AListener的开发人员能够看到CSystem的不同视图，并“看到”并且只能使用公开的方法。我不认为看到某个人实际上不能使用的方法是一个好主意（处理程序只有调度员才有意义）是否有一种模式可以实现这一点？

谢谢！

Answer 1

使用接口。 B与A的关系只能通过B定义和A实现的接口。

因此，从B的角度来看，它甚至不会导入A，或者在编译时访问A的定义。

针对问题编辑。

我beleive你有一些包一个xy格式C类

预先存在的，通过你unchangable，代码;

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）。匿名内部类。注意这里有一个没有公共方法的ia类，因此C不能使用它，但B在它可以使用的匿名内部类上有公共方法。

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 
} 

}

Answer 2

你可以把A和B在包欧米加包阿尔法和C。 A和B可以访问对方的包私有成员，但C不能。你也应该使用像djna所说的接口。

package alpha ; 
public interface A { void doSomething () ; } 
public interface B { } 
class AImpl implements A { ... void doSomethingPrivate () { ... } } 
class BImpl implements B { AImpl a ; ... a.doSomethingPrivate () ; } 

package omega ; 
public interface C { public void handle (alpha.a a) ; ... } 

Answer 3

您似乎有一个具有多个责任接口的类。这是一件坏事。一个简单的方法是使用匿名内部类来实现回调接口。

Answer 4

你可以做到这一点像：

interface EventSource<T>{ 
    void addEventListener(T listener); 
    void removeEventListener(T listener); 
} 
class B implements EventSource<SomethingListener> 
{ 
    A instA; 
    ... 
    public B(A instA) 
    { 
     this.instA = instA; 
     instA.installEventSource(this); 
     ... 
    } 
    ... 
} 
class A 
{ 
    ... 
    public void installEventSource(EventSource source) 
    { 
     source.addEventListener(listener); 
    } 
    public void uninstallEventSource(EventSource source) 
    { 
     source.removeEventListener(listener); 
    } 
} 

Answer 5

感谢您的例子！ 我似乎并不清楚。 ，有很多的方法和处理我所说的

public class Csystem() 
{ 

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

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


} 

CSystem我有类Csystem是一个类，基本上是其他组件的其他开发者我的代码的接口。其他一些开发人员将编写他自己版本的AListener类（A类），并在他的代码中使用Csystem。 每当一个事件的某处发生（如网络中的消息到达），B级将事件传递给CSystem

的事件处理程序

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

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

} 

我的问题是，无论是类分（通过我实现）和类AListener“看到“CSystem的相同界面。我希望实现AListener的开发人员能够看到CSystem的不同视图，并“看到”并且只能使用公开的方法。我不认为看到某些人实际上不能使用的方法是一个好主意（处理程序仅供调度员使用有意义） 有没有一种模式可以实现这一点？