El modo Observador es uno de los modos de diseño de software y también se usa comúnmente, especialmente en la programación de GUI. Hay muchos artículos sobre patrones de diseño escritos en Internet, y muchos artículos están bien escritos. Aunque existe la sospecha de repetir la rueda temprana, esta rueda no es la otra rueda, con diferentes enfoques, diferentes ideas y diferentes formas de contarla.
Elementos clave
tema:
Un tema es el objeto observado por el observador. Un tema debe tener las siguientes tres características.
Observador:
Cuando cambia el sujeto, recibir notificaciones para un procesamiento específico es una característica que debe tener el observador.
Por qué usar este modo
Aquí hay un ejemplo para ilustrar que la estación de entrega de leche es el tema. El cliente de suscripción de leche es el monitor. Después de que el cliente se suscribe a la leche de la estación de entrega de leche, recibirá la leche todos los días. Si el cliente no quiere suscribirse, puede cancelar y no recibirá leche en el futuro.
Acoplamiento suelto
El observador agrega o elimina el código sin modificar el tema, solo llame al método correspondiente para agregar o eliminar el tema.
El sujeto solo es responsable de notificar al observador, pero no necesita saber cómo el observador trata con la notificación. Por ejemplo, la estación de entrega de leche solo es responsable de entregar leche y no le importa si el cliente la bebe o se lava la cara.
El observador solo necesita esperar la notificación del tema, sin observar los detalles relacionados con el tema. En cuanto al mismo ejemplo, los clientes solo necesitan preocuparse por la estación de entrega de leche para entregar la leche, no sobre de qué mensajero es o de qué tipo de transporte entregar la leche.
Java implementa el modo observador
1. Implementación propia de Java
Diagrama de clases
/ ** * El objetivo de observación hereda de java.util.observable * @author stone * */ public class UpdateObServable extiende observable {private int data; Public UpdateObServable (Observer Observer) {addObServer (observador); / * * Agregar otro observador */} public int getData () {return data; } public void setData (int data) {if (data! = this.data) {this.data = data; setchanged (); // Cambios de etiqueta, notifyObServers (); // notificación}} @Override public sincronizado void addobserver (observador o) {super.addoBServer (o); } @Override public sincronizado void deleteObServer (observador o) {super.deleteObServer (o); } @Override public void notifyObServers () {super.notifyObServers (); } @Override public void notifyObServers (objeto arg) {super.notifyObServers (arg); } @Override public sincronizado void deleteObServers () {super.deleteObServers (); } @Override protegido sincronizado void setchanged () {super.setchanged (); } @Override Proteged sincronizado void CLearchanged () {super.clearchanged (); } @Override public sincronizado boolean haschanged () {return super.haschanged (); } @Override public sincronizado int countObServers () {return super.countObServers (); }} / ** * Observador implementa java.util.observer Interface * @author Stone * */ public class UpdateObServer implementa observador {@Override public void Update (observable o, objeto arg) {system.out.println ("recibió notificación de cambio de datos:"); if (o instancia de updateObServable) {updateObServable uo = (updateObServable) o; System.out.print ("Datos cambiados a:" + uo.getData ()); }}} 2. Modelo de observación personalizado
Diagrama de clases
/ ** * Observador abstracto * Actualización de observación * @author Stone * */ Public Interface iWatcher {/ * * Interfaz de notificación: * 1. Notificación simple * 2. El observador necesita datos del cambio del objetivo, para que el objetivo se pueda usar como un parámetro, consulte el observador de Java y observable * // Actualización (actualización); ovoid Update (); } / ** * El sujeto de destino abstracto * proporciona una interfaz para registrar y eliminar objetos Observer, y una interfaz para notificar a los observadores que observen * y la interfaz a la que se observa el objetivo * @Author Stone * */ Public Interface iWatchedSubject {public void add (iWatcher Watch); Public Void Retember (IWatcher Watch); public void notifywhatchers (); Public void Update (); // Interfaz a los cambios comerciales observados} / ** * Observador específico Observador concreto * * @author Stone * */ public class UpdateWatcher implementa iWatcher {@Override public void update () {System.out.println (this + "observado: el objetivo se ha actualizado"); }} / ** * Colter de destino específico Asunto concreto * @author Stone * */ public class UpdateWatchedSubject implementa iWatchedSubject {Lista privada <Iwatcher> LIST; Public UpdateWatchedSubject () {this.list = new ArrayList <Iwatcher> (); } @Override public void add (watch iwatcher) {this.list.add (watch); } @Override public void Remete (IWatcher Watch) {this.list.remove (reloj); } @Override public void notifyWhatchers () {for (iWatcher Watcher: list) {Watcher.Update (); }} @Override public void Update () {System.out.println ("Actualización de destino ......"); notifywhatchers (); }} Un oyente es una implementación del observador:
Diagrama de clases
/ ** * oyente después de registrarse * @author Stone * */ Public Interface IreGisterListener {void onregistered (); } / ** * oyente Cuando el usuario inicia sesión * @author Stone * */ Public Interface iLoginListener {void onLoged (); } /** El oyente es una implementación del modo Observador* Agregar oyentes a algunas interfaces comerciales que requieren escuchar, llame a los métodos correspondientes del oyente para implementar escucha*/ public class user {public void Register (IREGisterListener Register) {/** do ... registrar*/ system.out.println ("registrando ..."); // después de registrar registro.onregistered (); } public void login (IloGinListener login) { / * * do ... login * / system.out.println ("registrando ..."); // después de login.onlogined (); }} /*** Patrón de comportamiento del modo observador* El modo Observador define una dependencia de uno a muchos, lo que permite que múltiples objetos observadores observen un objeto objetivo al mismo tiempo. * Cuando este objeto objetivo cambia en su estado, notificará a todos los objetos del observador, para que puedan actualizarse automáticamente. El objeto de destino necesita una interfaz para agregar, eliminar y notificar a los observadores * * @author stone */ public class test {public static void main (string [] args) {/ * * use la interfaz de observador de Java y la clase observable */ updateObServable observable = new UpdateObServable (New UpdateObServer ()); observable.setData (99); System.out.println (""); System.out.println (""); /** Modelo de observador personalizado*/ iWatchedSubject Watched = new UpdateWatchedSubject (); watched.Add (nuevo updateWatcher ()); watched.Add (nuevo updateWatcher ()); watched.update (); System.out.println (""); /** Sub-Mode-Listener*/ User User = New User (); user.register (new IreGisterListener () {@Override public void onregistered () {System.out.println ("Después de escuchar el registro ...");}}); user.login (new IloGinListener () {@Override public void onLoged () {System.out.println ("Después de escuchar el inicio de sesión ...");}}); }}Imprimir
Notificación recibida del cambio de datos: datos cambiados a: 99 El objetivo se está actualizando ... observador.updatewatcher@457471E0 Observado: El objetivo se ha actualizado observador.updatewatcher@5fe04cbf observado: El objetivo se ha actualizado y se ha registrado ... después de escuchar el registro. . . Iniciar sesión ... después de escuchar iniciar sesión. . .