Padrões observadores compreensão

Video: A NECESSIDADE DO OBSERVADOR E DO PONTO DE VISTA NA COMPREENSÃO DA PAISAGEM URBANA

O padrão de projeto Observer permite que objetos de vários observadores ser notificado quando um objeto objeto for alterada de alguma forma. Cada observador registra com o assunto, e quando ocorre uma alteração, o assunto notifica todos eles. Cada um dos observadores é notificado em paralelo (isto é, ao mesmo tempo).

Criando uma interface de assunto

Quando você implementar um padrão de design, muitas vezes é uma boa idéia para começar por criar uma interface para se certificar de que os objetos que você criar irá aderir ao padrão que você está tentando usar - especialmente se vários objetos estão envolvidos. Implementar essa interface - programar para uma interface, como é chamado - mantém o seu código na linha e geralmente mantém as coisas mais claras.

Quando você está colocando o padrão Observer em código, criar uma interface ou classe abstrata para o observers- normalmente você vai ter vários observadores, e você tem que manter os métodos que implementam consistente.

Neste exemplo, você também precisa configurar uma interface para o assunto, que é o que os observadores de vigia a interface Assunto lista os métodos de assuntos deve implementar. Coloque um método registerObserver para que o assunto possa manter o controle de observadores que querem ser registrado. Além de registrar observadores, você deve ter alguma maneira de se livrar deles, então adicionar um método removeObserver. E não há um método notifyObservers que irá notificar os observadores de alguma mudança.

interface pública Assunto
{
registerObserver public void (Observer o) -
removeObserver public void (Observer o) -
notifyObservers public void () -
}

Esta interface lista os métodos que temas como o sistema de banco de dados deve implementar. Próximo passo: a interface para os observadores.

Criando uma interface de observador

Criando a interface Observer, implementada pelos observadores que lhes permitam obter notificações, é simples. Tudo que você precisa é um método que será chamado quando uma nova notificação está pronto (você pode chamar esse método update). Neste exemplo, você passar a operação de banco de dados que foi realizada (como em “editar”, “delete”, “criar” e assim por diante) e o registro que foi alterado como cordas para o método de atualização.

Observer interface pública
{
public void update (operação de Cordas, ficha String) -
}

Quando os observadores implementar o método de atualização, o sujeito é capaz de passá-los o registro que tem sido afetada e a operação que foi realizada.

Ok, você está pronto para ir. É hora de criar o assunto de banco de dados que vai manter o controle dos observadores e notificá-los quando houve uma mudança.

Criando um assunto

O sujeito tem de deixar observadores registrar e tem que notificá-los quando um evento ocorre. De acordo com a interface Objecto, os três métodos de um sujeito tem de implementar nestes exemplos são: registerObserver, removeObserver, e notifyObservers. Isso é o que a classe de banco de dados faz neste exemplo.

Para manter o controle dos observadores, use um vetor Java chamado observadores, criado no construtor base de dados. (O tipo especificador aqui, , é para Java 1.5 ou posterior e indica que cada objeto observador implementa o Observer interface- se você estiver usando uma versão anterior do Java, omitir o especificador de tipo.)

importar java.util. * -
classe pública banco de dados implementa Assunto
{
Vector privada observadores;

Banco de dados público ()
{
observadores = new Vector() -
}
.
.
.
}

Quando você usa um vetor, mantendo o controle de observadores é simples. Quando um observador quer registar, ele chama o método registerObserver do sujeito, passando-se como um objeto. O assunto - um objeto da nossa classe de banco de dados - só tem a acrescentar que observador ao vetor de observadores no método registerObserver, utilizando o método add da classe Vector.

Video: Observadores Europeus Referendo Na Turquia Não Seguiu Padrões Internacionais

importar java.util. * -
classe pública banco de dados implementa Assunto
{
Vector privada observadores;

Banco de dados público ()
{
observadores = new Vector() -
}

Video: Camuflagem de Polvo surpreende pelo grau de complexidade e mistério. Com legendas CC

registerObserver public void (Observer o)
{
observers.add (o) -
}
.
.
.
}

Como sobre a remoção de um observador do vetor observadores? Sem problemas. Quando você quiser remover um objeto a partir de um vetor, você pode usar remove do vetor metodolo- aqui está como isso funciona no método removeObserver da classe Base de dados:

Video: Junji Ito - Spiral Into Horror | Monsters of the Week

importar java.util. * -
classe pública banco de dados implementa Assunto
{
Vector privada observadores;

Banco de dados público ()
{
observadores = new Vector() -
}

registerObserver public void (Observer o)
{
observers.add (o) -
}

removeObserver public void (Observer o)
{
observers.remove (o) -
}
.
.
.
}

Quando o usuário realmente faz algo com o banco de dados - exclui um registro, por exemplo -, ele chama o método editRecord da classe de banco de dados. Por exemplo, para excluir ficha 1, que você pode chamar esse método como este:

database.editRecord ( “delete”, “ficha 1”);

Aqui está o que o método editRecord parece: Quando este método é chamado, você passá-lo a operação de banco de dados que deseja realizar e o registro que você deseja trabalhar, tanto como cordas neste exemplo. Essas cordas são armazenados para que possam ser repassados ​​para os observadores. Após as cordas são armazenados, o método notifyObservers, chegando próximo, é chamado para notificar todos os observadores.

importar java.util. * -
classe pública banco de dados implementa Assunto
{
Vector privada observers-
operação-private String
registro de private String;

Banco de dados público ()
{
observadores = new Vector() -
}
.
.
.
(Operação de Cordas, ficha String) public void editRecord
{
this.operation = operação-
this.record = Gravação
notifyObservers () -
}
}

Aqui está a carne do código, a parte que notifica cada observador que houve uma mudança: o método notifyObservers. Cada observador implementa a interface Observer deste exemplo - o que significa que tem um método de atualização - por isso notifyObservers só tem que varrer todos os observadores registados no vetor de observadores, chamando de cada um método de atualização com a operação de banco de dados e registro afetado.

importar java.util. * -
classe pública banco de dados implementa Assunto
{
Vector privada observers-
operação-private String
Gravação private String
.
.
.
notifyObservers public void ()
{
para (int loopIndex = 0- loopIndex lt; observers.size () - loopIndex ++) {
Observador observador = (observador) observers.get (loopIndex) -
observer.update (operação, ficha) -
}
}

(Operação de Cordas, ficha String) public void editRecord
{
this.operation = operação-
this.record = Gravação
notifyObservers () -
}
}

Isso é tudo que você precisa para Database.java, o assunto neste exemplo. O assunto vai deixar observadores registar-se, cancelar o registro si mesmos, e ser notificado quando um registro de banco de dados foi editado (o que você faz com o método editRecord da classe de banco de dados). Tudo o que resta a fazer para obter este show na estrada é criar os próprios observadores.