Implementieren eines Zuhörers für eine Klasse statt einer Instanz

Question

Ich habe viel von Instanzen der Klasse MyClass und sie ALL haben MyEventClass zu einem gewissen erzeugte Ereignis aus einer anderen Klasse zu reagieren. Wie soll ich das machen?

Mein erster Gedanke war ein Zuhörer in MyEventClass und implementieren sie in MyClass zu definieren, aber dies würde für jede Instanz von MyClass erfordern den Hörer zu setzen, und zusätzlich den Hörer als ein Array in MyEventClass zu definieren.
Eine Menge Code/Arbeit.

Eine weitere Option Ich dachte, ausgestrahlt in MyEventClass und Empfänger in MyClass verwenden, aber ich bin nicht sicher, vielleicht ist overkilling, und der Empfänger als auch (und nicht registriert auf onStop())

einem dritte zu registrier Die Option wäre, die Listener-Implementierung für die Klasse MyClass zu definieren, nicht für jede Instanz, das würde perfekt passen, aber ich weiß nicht, ob es überhaupt möglich ist und wie ich es programmieren soll.

noch eine vierte Option Ich kam gerade mit, ist der Hörer auf der übergeordneten Klasse von MyClass zu implementieren und nur diesen Zuhörer in MyEventClass Einstellung, dann auf den Ereignisfall-Schleife durch alle Instanzen MyClass und ihre Zuhörer manuell aufrufen. Dies erspart mir die Registrierung jeder Instanz mit MyEventClass.

Answer 1

StinePike rechts auf dieser ist, ist dies ein sehr Standardproblem zu begegnen, wenn Codierung. Das Muster Observer (oder Listener in Java talk) ist die Standard-Praxislösung dafür. Du solltest deine erste Aussage, die du irgendwie unklar formuliert hast, verwenden, also werde ich es für dich auslegen, für den Fall, dass ich nicht zu klar bin.

Lassen Sie MyEventClass bieten eine Listener-Schnittstelle, wie MyEventClassListener, und hinzufügen/entfernen Methoden. Dann kann sich MyClass als Listener anhängen/lösen. Hier ist ein Codebeispiel, falls Sie es brauchen:

MyEventClass.java

public class MyEventClass { 

    private Set<MyEventClassListener> listeners = new HashSet<MyEventClassListener>(); 

    // Your code here... 

    public void addListener(MyEventClassListener listener) { 
     listeners.add(listener); 
    } 

    public void removeListener(MyEventClassListener listener) { 
     listeners.remove(listener); 
    } 

    public void notifyListeners() { 
     for (MyEventClassListener listener : listeners) { 
      listener.somethingHappened(); 
     } 
    } 

} 

MyEventClassListener.java

public interface MyEventClassListener { 

    public void somethingHappened(); 

} 

MyClass. java

public class MyClass implements MyEventClassListener { 

    MyEventClass myEventClass; 

    // Your code here.. 

    public void someFunction() { 
     // Add as listener 
     myEventClass.addListener(this); 
    } 

    @Override 
    public void somethingHappened() { 
     // Act on callback 
    } 

} 

Answer 2

Ich denke Observer design pattern Ihre beste Wahl sein wird ..

Das Muster Beobachter ist ein Software-Entwurfsmuster in dem ein Objekt, das Subjekt genannt, führt eine Liste ihrer Familienangehörigen, genannt Beobachter und benachrichtigt sie automatisch über alle Statusänderungen, normalerweise durch den Aufruf einer ihrer Methoden. Es ist vor allem Systeme

mit Tausenden anderer Links Handhabung zu implementieren verteilt Ereignis verwendet werden, können Sie diese link1 überprüfen, link2