Código fuente de clase 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 comando Parámetros de fila
*/
Public static void main(String[] args) {
ObserverA a = new ObserverA();
ObserverB b = new ObserverB();
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 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 El patrón de observador consiste en 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.