Implementar un escucha para una clase en lugar de una instancia

Tengo un montón de instancias de clase MyClass y todos tienen que reaccionar a algún evento generado de otra clase MyEventClass . ¿Cómo debería hacer esto?

Mi primer pensamiento fue definir un listener en MyEventClass e implementarlo en MyClass , pero esto requeriría que cada instancia de MyClass estableciera el listener y además definir el listener como una matriz en MyEventClass .
Mucho código / trabajo.

Otra opción que he pensado es usar broadcast en MyEventClass y los receptores en MyClass , pero no estoy seguro, tal vez es overkilling, y los receptores deben ser registrados también (y no registrados en onStop() )

Una tercera opción sería definir la implementación de listener para la clase MyClass , no para cada instancia, esto encajaría perfectamente, pero no sé si es posible en absoluto y cómo hago para codificarlo.

Sin embargo, una cuarta opción que se me ocurrió, es implementar el listener en la clase padre de MyClass y sólo establecer este listener en MyEventClass , luego en el bucle de ocurrencia de evento a través de todas las instancias de MyClass y llamar manualmente a sus oyentes. Esto me ahorra registrar cada instancia con MyEventClass .

StinePike tiene razón en esto, este es un problema muy estándar que encontrar cuando se codifica. El patrón Observer (o Listener en Java) es la solución de práctica estándar para esto. Debería usar su primera proposición, que usted redactó de manera poco clara, por lo que la pondré en su lugar en caso de que no esté demasiado claro.

Deje que MyEventClass ofrezca una interfaz de Listener, como MyEventClassListener , y agregue / quite métodos. Entonces MyClass puede adjuntar / separarse como oyentes. He aquí un ejemplo de código en caso de que lo necesite:

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 } }

Creo que el Observer design pattern será su mejor opción ..

El patrón observador es un patrón de diseño de software en el que un objeto, llamado sujeto, mantiene una lista de sus dependientes, llamados observadores, y los notifica automáticamente de cualquier cambio de estado, usualmente llamando a uno de sus métodos. Se utiliza principalmente para implementar sistemas distribuidos de manejo de eventos

Con miles de otros enlaces que puede comprobar estos link1 , link2