【texto】
1. Definição de padrão de observador:
Simplificando, o padrão do observador define uma dependência um para muitos, permitindo que um ou mais objetos observadores ouçam um objeto de tópico. Dessa forma, quando o estado observado muda, o observador correspondente precisa ser notificado para que esses objetos observadores possam ser atualizados automaticamente. Por exemplo: o mecanismo de processamento de eventos na GUI adota o modo Observer.
2. Implementação do modo de observador:
Assunto (interface do objeto a ser observada): especifica a interface unificada do concreto -subjacente; Cada sujeito pode ter vários observadores; Concretesubject (objetos observados específicos): mantém uma lista de referências a todos os observadores específicos; Quando o status mudar, uma notificação será enviada a todos os observadores registrados. Observador (interface do observador): especifica a interface unificada do concretoerver; Define um método update (), que será chamado quando o estado do objeto observado for alterado. Concreteobserver: mantém uma referência ao concreto -subjacto; O estado específico é sincronizado com concreto -subjecto; implementa a interface do observador, a função do método update (): Uma vez que uma alteração no assunto for detectada, as informações serão atualizadas.
O diagrama é descrito da seguinte forma:
Nota: Há um conjunto na classe observada para manter todos os observadores.
3. Dê exemplos:
[Esquema 1]: Defina a interface ou a classe para implementar o padrão do observador.
As etapas são as seguintes:
(1) Defina a interface possuída pelo observador:
pacote com.vince.observer; interface pública observável {// Registre -se como um observer public void RegisterObServer (observador observador); // cancelar o observador o observador void removebserver (observador observador); // notifique todos os observadores para atualizar informações públicas void notifyObservers ();}(2) Defina o observador específico: copo
pacote com.vince.observer; importar java.util.Vector; public Class Cup implementa observáveis {// Uma lista de objetos de observador mantidos pelo vetor privado do observador <Teverver> vetor = new Vector <Berverver> (); Preço de flutuação privada; Public Cup (Price Float) {this.price = Price; } public float getPrice () {Return Price; } public void setPrice (preço float) {// notifique todos os observadores ao modificar o preço this.price = price; notifyObServers (); } @Override public void RegisterObServer (Observer Observer) {// Registre o observador Vector.add (Observer); } @Override public void RemowObServer (Observer Observer) {// Cancelar observador vetor.remove (observador); } @Override public void notifyObServers () {// Implemente notifique todos os objetos do observador para (observador observador: vetor) {observer.update (preço); }}}(3) Defina a interface comum que o observador possui: (Atualmente, a atualização dos dados é, obviamente, o resultado final deve ser realizado com o observador)
pacote com.vince.observer; public interface Observer {public void update (preço float); 5}(4) Defina objetos específicos do observador:
pacote com.vince.observer; public class Pessoa implementa o observador {nome da string privada; Pessoa pública (nome da string) {this.name = name; } @Override public void update (preço float) {System.out.println (nome+"O preço do copo que você está seguindo foi atualizado para:"+preço); }}(5) Teste:
pacote com.vince.observer; public class Test {public static void main (string [] args) {// crie um objeto de objeto Objeto Doll = new Cup (3000); // Crie dois objetos de observador Pessoa P1 = New Pessoa ("Life 1"); Pessoa P2 = nova pessoa ("Life 2"); // Registre -se como uma boneca de observador.RegisterObServer (P1); Doll.RegisterObServer (P2); System.out.println ("Primeira rodada de promoção:"); DOLL.SETPRICE (2698); // Alterações de preço System.out.println ("Promoção da segunda rodada:"); Doll.setPrice (2299); // System.out.println ("Promoção da segunda rodada:"); Doll.setPrice (1998); DOLL.RemoveObserver (P2); // Remova o Life 2 System.out.println ("Promoção da quarta rodada:"); Doll.setPrice (1098); }}Após a execução, os resultados são exibidos da seguinte forma:
[Esquema 2]: Ligue diretamente à API JDK para implementá -lo.
As etapas são as seguintes:
(1) Implementar o objeto observador específico herdando a classe observável:
pacote com.vince.observer2; importar java.util.observable; copo de aula pública estende observável {private flutuante preço; Public Cup (Price Float) {this.price = Price; } public float getPrice () {Return Price; } public void SetPrice (preço float) {this.price = price; this.Setchanged (); // Notificação, os dados mudaram isso.NotifyObServers (); }}(2) Implementar objetos de observador específicos implementando a interface java.util.observer:
pacote com.vince.observer2; importar java.util.observable; importar java.util.observer; public class Pessoa implementa o observador {private string name; Pessoa pública (nome da string) {this.name = name; } @Override public void update (obsertable o, objeto arg) {if (o instanceof cup) {cop cop = (cop) o; System.out.println (nome+"O preço do copo que você está seguindo foi atualizado para:"+cup.getprice ()); }}}(3) Teste:
pacote com.vince.observer2; public class Test {public static void main (string [] args) {cop cup = new cop (3000); Pessoa P1 = Nova pessoa ("Life 1"); Pessoa P2 = nova pessoa ("Life 2"); Cup.Addobserver (P1); Cup.Addobserver (P2); System.out.println ("Primeira rodada de promoção"); cup.setPrice (2988); System.out.println ("Segunda rodada de promoção"); cup.setPrice (2698); Cup.DeleteObServer (P2); System.out.println ("Terceira rodada de promoção"); Cup.setPrice (1998); }}Após a execução, os resultados são os seguintes:
【Documentos do projeto】
Link: http://xiazai.vevb.com/201609/yuanma/javaseguancha(vevb.com).rar
4. Resumo: (o papel do modo Observador)
O padrão do observador cria um acoplamento abstrato entre o observador e o observador. Todos os personagens do observador sabem que é apenas uma lista específica de observadores.
Como o observador e o observador não estão intimamente acoplados, eles podem pertencer a diferentes níveis de abstração. Se o observador e o observador forem reunidos, o objeto deve atravessar os níveis de abstração e concretização.
O modo de observador suporta comunicação de transmissão. O Observer emitirá um aviso a todos os observadores registrados.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.