【texto】
1. Definición de patrón de observador:
En pocas palabras, el patrón del observador define una dependencia de uno a muchos, lo que permite que uno o más objetos de observador escuchen un objeto de tema. De esta manera, cuando el estado observado cambia, el observador correspondiente debe ser notificado para que estos objetos del observador puedan actualizarse automáticamente. Por ejemplo: el mecanismo de procesamiento de eventos en la GUI adopta el modo Observador.
2. Implementación del modo Observador:
Sujeto (interfaz de objeto a observar): especifica la interfaz unificada de concreteSubject; Cada sujeto puede tener múltiples observadores; ConcreteSubject (objetos observados específicos): mantiene una lista de referencias a todos los observadores específicos; Cuando cambia el estado, se enviará una notificación a todos los observadores registrados. Observador (Interfaz Observer): especifica la interfaz unificada de ConcreteBServer; Define un método Update (), que se llamará cuando cambia el estado del objeto observado. ConcreteBServer: mantiene una referencia a ConcreteSubject; El estado específico se sincroniza con concreteSubject; Implementa la interfaz Observador, la función del método Update (): una vez que se detecta un cambio en el sujeto, se actualizará la información.
El diagrama se describe de la siguiente manera:
Nota: Hay un conjunto en la clase observada para mantener a todos los observadores.
3. Dar ejemplos:
[Esquema 1]: Defina la interfaz o clase usted mismo para implementar el patrón de observador.
Los pasos son los siguientes:
(1) Defina la interfaz que posee el observador:
paquete com.vince.observer; interfaz pública observable {// registrarse como observador public void registreBServer (observador observador); // Cancelar el observador público Void RemoLoBServer (Observer Observer); // notifica a todos los observadores que actualicen información public void notifyObServers ();}(2) Defina el observador específico: taza
paquete com.vince.observer; import java.util.vector; public class Cup implementa observable {// una lista de objetos observadores mantenidos por el observador privado Vector <Smanter> vector = new Vector <SBServer> (); precio flotante privado; Public Cup (Price Float) {this.price = Price; } public float getPrice () {precio de retorno; } public void setPrice (Price Float) {// notifica a todos los observadores al modificar el precio this.price = precio; notifyObServers (); } @Override public void RegistroBServer (Observer Observer) {// Registre Observer Vector.Add (Observer); } @Override public void RemoLoBServer (Observer Observer) {// Cancelar Observer vector.remove (observador); } @Override public void notifyObServers () {// implementar notificar todos los objetos observadores para (observador observador: vector) {observador.update (precio); }}}(3) Defina la interfaz común que tiene el observador: (actualizar los datos es, por supuesto, el resultado final se llevará a cabo con el observador)
Paquete com.vince.observer; Public Interface Observer {public void Update (Price Float); 5}(4) Definir objetos de observador específicos:
paquete com.vince.observer; la persona de clase pública implementa observador {nombre de cadena privada; Persona pública (nombre de cadena) {this.name = name; } @Override public void Update (Float Price) {System.out.println (nombre+"El precio de la copa que está siguiendo se ha actualizado a:"+precio); }}(5) Prueba:
paquete com.vince.observer; prueba de clase pública {public static void main (string [] args) {// crea un objeto observador copa doll = nueva copa (3000); // crear dos objetos observadores persona p1 = nueva persona ("vida 1"); Persona P2 = nueva persona ("Vida 2"); // registrarse como una muñeca observador. RegisterObServer (P1); muñeca. RegisterObServer (P2); System.out.println ("Primera ronda de promoción:"); Doll.SetPrice (2698); // El precio cambia System.out.println ("Promoción de segunda ronda:"); Doll.SetPrice (2299); // System.out.println ("Promoción de segunda ronda:"); Doll.SetPrice (1998); Doll.RemoveObServer (P2); // eliminar la vida 2 System.out.println ("promoción de cuarta ronda:"); Doll.SetPrice (1098); }}Después de ejecutar, los resultados se muestran de la siguiente manera:
[Esquema 2]: llame directamente a la API JDK para implementarla.
Los pasos son los siguientes:
(1) Implemente el objeto Observador específico heredando la clase observable:
paquete com.vince.observer2; import java.util.observable; public class Cup extiende observable {precio flotante privado; Public Cup (Price Float) {this.price = Price; } public float getPrice () {precio de retorno; } public void setPrice (Price Float) {this.price = precio; this.setchanged (); // notificación, los datos han cambiado esto.notifyObServers (); }}(2) Implementar objetos de observador específicos implementando la interfaz java.util.observer:
paquete com.vince.observer2; import java.util.observable; import java.util.observer; la persona de clase pública implementa observador {nombre de cadena privada; Persona pública (nombre de cadena) {this.name = name; } @Override public void Update (observable o, objeto arg) {if (o instanciaf copa) {copa cup = (cup) o; System.out.println (nombre+"El precio de la copa que está siguiendo se ha actualizado a:"+cup.getPrice ()); }}}(3) Prueba:
paquete com.vince.observer2; prueba de clase pública {public static void main (string [] args) {copa cup = new Cup (3000); Persona p1 = nueva persona ("vida 1"); Persona P2 = nueva persona ("Vida 2"); CUP.AddoBServer (P1); Cup.addobserver (P2); System.out.println ("Primera ronda de promoción"); Cup.setPrice (2988); System.out.println ("Segunda ronda de promoción"); Cup.setPrice (2698); copa.deleteobserver (P2); System.out.println ("Tercera ronda de promoción"); Cup.SetPrice (1998); }}Después de ejecutar, los resultados son los siguientes:
【Documentos del proyecto】
Enlace: http://xiazai.vevb.com/201609/yuanma/javaseguancha(vevb.com).rar
4. Resumen: (el papel del modo observador)
El patrón del observador crea un acoplamiento abstracto entre el observador y el observador. Todos los personajes de observadores saben es solo una lista específica de observadores.
Dado que el observador y el observador no están estrechamente acoplados juntos, pueden pertenecer a diferentes niveles de abstracción. Si tanto el observador como el observador se unen, entonces el objeto debe cruzar los niveles de abstracción y concreto.
El modo Observador admite la comunicación de transmisión. El observador emitirá un aviso a todos los observadores registrados.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.