Compartir código fuente java
Importar Java util .iterador
Importar Java util . p>
* @authorSeastar
*/
Interfaz observada {
public void addObserver(observador o);
público void eliminar Observer(Observador o);
Actualización pública void();
}
Interfaz Observador{
public void tomar acción ();
}
Categoría llamante {
Observador privado o;
Manejador manejador;
Público llamador (observador o) {
new Handler();
this.o = o
}
El controlador de clase privada extiende el hilo {
Manejador público(){
handler = this
}
@ Override
Ejecución de anulación pública (){
o . tomar acción();
}
}
prueba booleana pública mismo observador(Observador o){
return o = = this.o
}
public void invoke() {
handler start();
}
}
Clase ObservedObject implementa Observado {
Vector privado ltInvoker gtobserverList = new Vector ltInvoker gt();
public void addObserver(observador o) {
lista de observadores add(new Invoker(o));
}
public void remove Observer(Observador). o){
Iterador ltInvoker gtit = lista de observadores . iterador();
mientras (it.hasNext()) {
invocador I = siguiente. ();
if (i.TestSameObserver(o)) {
lista de observadores .eliminar(I);
p>
Romper;
}
}
}
Actualización de anulación pública(){
para (Invoker i: observerList) {
I . invoke();
}
}
}
La clase de la era Observer implementa Observer {
Operación pública no válida(){
System.out.println("Soy el observador A, el estado ha cambiado, así que necesito hacer el pedido");
}
}
ObservadorB
La clase implementa Observador {
Operación de anulación pública(){
System.out.println("Soy el observador B, me dicen que haga algo");
}
}
Class Observer RC implementa la {
operación de anulación pública (){
System.out(. "Soy el observador C, solo miro y no hago nada");
}
}
Clase pública principal {
/ **
* @param args parámetros de línea de comando
*/
Public static void main(String[] args) {
ObservadorA a = nuevo ObservadorA();
ObservadorB b = nuevo ObservadorB();
observador RC c = nuevo observador RC();
objeto observado oo = nuevo objeto observado();
oo . addobserver(a);
oo . /p>
for(int I = 0; ilt5; i) {
oo.addObserver(new observer(){
operación pública no válida(){
System.out.println("Soy un observador imitador" "¿Quién se atreve a detenerme");
}
});
}
//A veces oo cambia, por lo que llama a update y notifica a todos los observadores
oo update();
}
La esencia del patrón de observador es registrar un observador para observar objetos que pueden cambiar en cualquier momento y notificar automáticamente al observador cuando el objeto cambia.
Esto es muy útil cuando el alcance de la influencia del objeto observado es grande y puede causar cambios en el comportamiento de múltiples clases, porque las clases afectadas por el objeto observado se pueden agregar sin modificar el código del objeto observado. objeto. Este patrón de diseño hace que el código sea más fácil de administrar y mantener y reduce la posibilidad de errores.
En cuanto al mecanismo asincrónico, en realidad es un truco. Esto se puede lograr observando el objeto o al propio observador. En realidad, este programa implementa el mecanismo asincrónico envolviendo una clase de invocador en la clase de observador.