Código fuente subyacente vectorial
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. eliminar Observador(Observador o){
Iterador & ltInvoker & gtit = lista de observadores
mientras (it .hasNext()) {
. invocador I = it . next();
if (i.TestSameObserver(o)) {
lista de observadores (I);
Romper;
}
}
}
Actualización de anulación pública(){
para (Invoker i: observerList ) {
I .invoke();
}
}
}
La clase de la era Observador implements Observer {
Operación pública no válida (){
System.out.println("Soy el observador A, el estado cambia, así que tengo que hacer algo");
}
}
La clase ObserverB implementa Observer {
Operación de anulación pública ( ){
System.out .println("Soy el observador B, me dicen que haga algo");
}
} >Class Observer RC implementa Observer { Operación pública no válida (){ System.out.println("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 = new ObservadorA(); ObservadorB b = nuevo ObservadorB(); observador RC c = nuevo observador RC(); objeto observado oo = nuevo objeto observado(); oo . (a); oo .addobserver(b); oo .addobserver(c); i) { oo.addObserver(new Observer(){ Operación de anulación pública(){ System.out. println("Soy un imitador observador" + "Quién se atreve a detenerme"); } }); } //A veces cambia , por lo que llama a update y notifica a todos los observadores oo update(); } } La esencia del observador. El patrón 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 solo 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.