Implementare un listener per una Classe invece di un'istanza

Question

ho un sacco di istanze della classe MyClass e ALL dover reagire a qualche evento generato da un'altra classe MyEventClass. Come dovrei farlo?

mio primo pensiero è stato quello di definire un ascoltatore MyEventClass e implementare in MyClass, ma ciò richiederebbe per ogni istanza di MyClass per impostare l'ascoltatore, e in aggiunta per definire l'ascoltatore come un array in MyEventClass.
Un sacco di codice/lavoro.

Un'altra opzione ho pensato è quella di utilizzare la trasmissione in MyEventClass e ricevitori in MyClass, ma non sono sicuro, forse è overkilling, ei ricevitori sono da registrare pure (e non registrati sul onStop())

Un terzo l'opzione sarebbe quella di definire l'implementazione listener per la classe MyClass, non per ogni istanza, questo si adatterebbe perfettamente, ma non so se è possibile del tutto e come faccio a codificarlo.

Eppure una quarta opzione Ho appena si avvicinò con, è quello di implementare l'ascoltatore in classe padre di MyClass e l'impostazione solo in questo ascoltatore in MyEventClass, allora il ciclo degli eventi verificarsi in tutte le istanze MyClass e chiamare manualmente i loro ascoltatori. Ciò mi consente di salvare ciascuna istanza con MyEventClass.

Answer 1

StinePike è proprio su questa manipolazione, questo è un problema molto standard di incontrare quando si scrive codice. Il pattern Observer (o Listener in Java talk) è la soluzione standard per questo. Dovresti usare la tua prima proposizione, che hai formulato un po 'poco chiara, quindi la illustrerò per te nel caso in cui non sia troppo chiaro.

Lascia che MyEventClass offra un'interfaccia Listener come MyEventClassListener e aggiungi/rimuovi metodi. Quindi MyClass può collegarsi/disconnettersi come ascoltatori. Ecco un esempio di codice in caso di necessità:

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

penso Observer design pattern sarà la vostra migliore scelta ..

Il pattern Observer è un design pattern in cui un oggetto, chiamato il soggetto, mantiene un elenco dei suoi dipendenti, chiamato osservatori, e notifica loro automaticamente eventuali cambiamenti di stato, di solito chiamando uno dei loro metodi. Viene principalmente utilizzato per implementare evento distribuito sistemi

con migliaia di altri collegamenti È possibile controllare questi link1, link2