O modo Observer é um dos modos de design de software e também é comumente usado, especialmente na programação da GUI. Existem muitos artigos sobre padrões de design escritos na Internet, e muitos artigos estão bem escritos. Embora exista uma suspeita de repetir a roda inicial, esta roda não é a outra roda, com foco diferente, idéias diferentes e diferentes maneiras de contar.
Elementos -chave
tema:
Um tópico é o objeto observado pelo observador. Um tópico deve ter as três características a seguir.
Observador:
Quando o sujeito muda, o recebimento de notificações para processamento específico é um recurso que o observador deve ter.
Por que usar este modo
Aqui está um exemplo para ilustrar que a estação de entrega de leite é o tema. O cliente de assinatura de leite é o monitor. Depois que o cliente se inscrever no leite da estação de entrega de leite, ele receberá o leite todos os dias. Se o cliente não quiser se inscrever, ele poderá cancelar e não receberá leite no futuro.
Acoplamento solto
O Observer adiciona ou exclui o código sem modificar o tópico, basta chamar o método correspondente de adicionar ou excluir o tópico.
O sujeito é responsável apenas por notificar o observador, mas não precisa saber como o observador lida com a notificação. Por exemplo, a estação de entrega de leite é responsável apenas por entregar leite e não se importa se o cliente bebe ou lava o rosto.
O observador só precisa esperar a notificação do tópico, sem observar os detalhes relacionados ao tópico. Quanto ao mesmo exemplo, os clientes só precisam se preocupar com a estação de entrega de leite para entregar o leite, não sobre de qual correio é ou que tipo de transporte entregar o leite.
Java implementa o modo de observador
1. Implementação de Java
Diagrama de classe
/ ** * O alvo de observação herda de java.util.observable * @author stone * */ public classe updateObservable estende observável {private int data; public updateObServable (Observer Observer) {addObServer (Observer); / * * Adicione outros observadores */} public int getData () {retornar dados; } public void setData (int data) {if (data! = this.data) {this.data = data; setChanged (); // alterações de tags, notifyObServers (); // notificação}} @Override public sincronizado void addObServer (observador o) {super.addobserver (o); } @Override Public sincronizado void DeleteObServer (Observer 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 Sincronizado protegido void setChanged () {super.Setchanged (); } @Override Sincronizada protegida void Clearchanged () {super.clearchanged (); } @Override public sincronizado boolean haschanged () {return super.haschanged (); } @Override public sincronizado int countObServers () {return super.countObServers (); }} / ** * Observer implementa java.util.observer interface * @author stone * */ public class UpdateObServer implementa observador {@Override public void update (observável o, objeto arg) {System.out.println ("Notificação recebida da mudança de dados:"); if (o instanceof updateObservable) {updateObservable uo = (updateObservable) o; System.out.print ("Dados alterados para:" + uo.getData ()); }}} 2. Modelo de observação personalizada
Diagrama de classe
/ ** * Atualização de observação abstrata * @Author Stone * */ interface pública Iwatcher {/ * * Interface de notificação: * 1. Notificação simples * 2. O observador precisa de dados da alteração do destino, para que o alvo possa ser usado como um parâmetro, consulte o observador de Java e o observável * // // atualize (iWatched); void update (); } / ** * Assunto de destino abstrato * fornece uma interface para registrar e excluir objetos de observador, e uma interface para notificar os observadores para observar * e a interface na qual o alvo é observado * @author stone * */ interface pública iwatchedSubject {public void Add (iwatcher watch); public void Remover (relógio Iwatcher); public void notifywhatchers (); public void update (); // interface para as mudanças de negócios observadas} / ** * Observador específico Observador Concreto * * @Author Stone * */ public class UpdateWatcher implementa Iwatcher {@Override public void update () {System.out.println (this + "observado: o destino foi atualizado"); }} / * * public updatewatchedsubject () {this.list = new ArrayList <iwatcher> (); } @Override public void add (iwatcher watch) {this.list.add (watch); } @Override public void Remover (relógio Iwatcher) {this.list.remove (watch); } @Override public void notifyWhatchers () {for (Watcher Watcher: List) {Watcher.Update (); }} @Override public void update () {System.out.println ("Atualização do Target ......"); notifywhatchers (); }} Um ouvinte é uma implementação do observador:
Diagrama de classe
/ ** * ouvinte depois de registrar * @Author Stone * */ interface pública IregisterListener {void onRegistered (); } / ** * ouvinte quando o usuário efetua login * @author stone * */ interface pública iloginListener {void onLogined (); } /** O ouvinte é uma implementação do modo de observador* Adicionar ouvintes a algumas interfaces de negócios que exigem ouvir, chame os métodos correspondentes do ouvinte para implementar a audição*/ public class Usuário {public void Register (registro de IregisterListener) {/** do ... registro*/ system.out.println ("registrando ..."); // após o registro Registration.Onregistered (); } public void Login (login Login) { / * * do ... login * / system.out.println ("registrando ..."); // depois do login.onLogined (); }} /*** Modo de observador Padrão comportamental* O modo Observador define uma dependência um para muitos, permitindo que vários objetos observadores observem um objeto de destino ao mesmo tempo. * Quando esse objeto de destino mudar em seu estado, ele notificará todos os objetos do observador, para que eles possam se atualizar automaticamente. O objeto de destino precisa de uma interface para adicionar, remover e notificar os observadores * * @Author Stone */ Public Class Test {public static void main (string [] args) {/ * * Use a própria interface do observador de Java e a classe observável */ updateObservable observável = new UpdateObServable (New UpdateObserver ()); obsertable.setData (99); System.out.println (""); System.out.println (""); /** Modelo de observador personalizado*/ iwatchedsubject watched = new updateWatchedSubject (); assistindo.add (new UpdateWatcher ()); assistindo.add (new UpdateWatcher ()); assistindo.Update (); System.out.println (""); /** Sub-Listener*/ Usuário do Usuário = new User (); user.register (new iRegisterListener () {@Override public void onRegistered () {System.out.println ("Após ouvir o registro ...");}}); user.login (new iloginListener () {@Override public void onLogined () {System.out.println ("Após ouvir o login ...");}}); }}Imprimir
Notificação recebida da alteração de dados: Dados alterados para: 99 O destino está sendo atualizado ... Observer.UpDateWatcher@457471E0 Observado: O alvo foi atualizado Observer.UpdateWatcher@5Fe04CBF observado: o alvo foi atualizado e está registrando ... Após a escuta do registro. . . Faça login ... depois de ouvir o login. . .