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的不同視圖，並「看到」並且只能使用公開的方法。我不認爲看到某些人實際上不能使用的方法是一個好主意（處理程序僅供調度員使用有意義） 有沒有一種模式可以實現這一點？