padrão Observer

Quando há muitos relacionamentos entre os objetos, use o padrão Observer (Observador Padrão). Por exemplo, quando um objeto é modificado, ele irá notificar automaticamente seus objetos dependentes. O observador padrão pertence a padrões comportamentais.

introdução

Intenção: definir as dependências entre objetos de um-para-muitos, quando o estado de um objeto é alterado, todos os objetos que dependem dele são notificados e atualizados automaticamente.

Principalmente para resolver: um estado da notificação de alteração de objeto para os problemas de outros objetos, mas também tendo em conta a facilidade de uso e baixo acoplamento, assegurar um elevado grau de colaboração.

Quando usar: um objeto (objeto de destino) muda de estado, todos os objetos dependentes (objetos de observação) será notificado, a notificação transmitida.

Como corrigir: o uso da tecnologia orientada a objetos, esta dependência pode ser enfraquecida.

O código-chave: classe abstrata tem um ArrayList armazenado observadores.

Exemplos de aplicação: 1, quando o leilão, o leiloeiro observar o preço mais alto, e depois notificar outros licitantes lance.2, Journey to the West dentro Wukong pedido de entrega Red Boy Buddha, água Buddha derramado sobre o piso de uma antiga provocam tartaruga, esta tartaruga é o observador, ele observou que a ação Buddha rega.

Vantagens: 1, o observador eo observado são abstratos acoplado.2, para estabelecer um mecanismo de gatilho.

Desvantagens: 1, se o objeto observado tem um monte de observador direta e indireta, ele irá notificar todos os observadores estão a gastar um monte de tempo.2, se há uma dependência circular entre o observador eo observado alvo, observar o alvo irá disparar chamadas para circular entre eles, pode causar a falha do sistema. 3, o modo de observador não existe nenhum mecanismo para permitir que o espectador conhecer o público é a forma como as mudanças observadas, mas só sei que as mudanças alvo de observação.

cenários de uso: 1, método comum sub-classe múltipla, e a mesma lógica.2, métodos importantes e complexas pode ser considerado como um método padrão.

Nota: 1, JAVA já tem observadores classes de suporte modo.2, para evitar referências circulares. 3, se a ordem de execução, um visualizador pode causar erros de sistema presos, geralmente usam o modo assíncrono.

realização

O observador padrão usando três classes Assunto, observador e cliente. Sujeito ao objeto cliente com o objeto e o observador é métodos observadores ligados amarradas Client Solutions a partir de objetos. Nós criamos aclasse Assunto,Observer classe abstrata e estender a classeObserverabstrato classe de entidade.

ObserverPatternDemo,nossas aulas de demonstração utilizando objetos de classe e entidadessujeitasa demonstrar o padrão Observer.

passo 1

Criar categoria de assunto.

Subject.java

importação java.util.ArrayList;
import java.util.List;

classe pública Assunto {
	
   Lista privada <Observer> observadores 
      = New ArrayList <Observer> ();
   Estado int privado;

   getState int pública () {
      estado retornar;
   }

   setState public void (estado int) {
      this.state = Estado;
      notifyAllObservers ();
   }

   public void anexar (Observer observador) {
      observers.add (observador);		
   }

   notifyAllObservers public void () {
      for (Observer observador: observadores) {
         observer.update ();
      }
   } 	
}

passo 2

Criar classe Observer.

Observer.java

Observer classe abstrata pública {
   protegidas assunto Assunto;
   void update abstrato pública ();
}

passo 3

Criar classe de entidade observadora.

BinaryObserver.java

classe pública BinaryObserver estende Observer {

   pública BinaryObserver (Reservamos o sujeito) {
      this.subject = assunto;
      this.subject.attach (this);
   }

   @Override
   public void update () {
      System.out.println ( "string binária:" 
      + Integer.toBinaryString (subject.getState ())); 
   }
}

OctalObserver.java

classe pública OctalObserver estende Observer {

   pública OctalObserver (Reservamos o sujeito) {
      this.subject = assunto;
      this.subject.attach (this);
   }

   @Override
   public void update () {
     System.out.println ( "Octal Cadeia:" 
     + Integer.toOctalString (subject.getState ())); 
   }
}

HexaObserver.java

classe pública HexaObserver estende Observer {

   HexaObserver público (assunto Assunto) {
      this.subject = assunto;
      this.subject.attach (this);
   }

   @Override
   public void update () {
      System.out.println ( "Hex Cadeia:" 
      + Integer.toHexString (subject.getState ()) .toUpperCase ()); 
   }
}

passo 4

Use objetos entidadesujeitae de observadores.

ObserverPatternDemo.java

ObserverPatternDemo classe pública {
   main (String [] args) public static void {
      Assunto subject = assunto novo ();

      nova HexaObserver (sujeito);
      nova OctalObserver (sujeito);
      nova BinaryObserver (sujeito);

      System.out.println ( "Primeira mudança de estado: 15");	
      subject.setState (15);
      System.out.println ( "Second mudança de estado: 10");	
      subject.setState (10);
   }
}

passo 5

Verifique saída.

Primeira mudança de estado: 15
Hex Cadeia: F
Cadeia Octal: 17
String binária: 1111
Segundo mudança de estado: 10
Hex Cordas: Um
Cadeia Octal: 12
String binária: 1010