Modo de observador (às vezes chamado de modo Publish-inscrição, modo de visualização de modelo, modo de listener de origem ou modo de escravo) é um tipo de modo de design de software. Nesse modo, um objeto de destino gerencia todos os objetos do observador que dependem dele e emitem ativamente notificações quando seu estado muda. Isso geralmente é alcançado chamando os métodos de cada observador. Esse padrão é geralmente usado para implementar sistemas de processamento de eventos.
O modo de observador separa perfeitamente o observador do objeto observado. Por exemplo, a interface do usuário pode ser usada como observador e os dados comerciais são o observador. A interface do usuário observa as alterações nos dados de negócios. Depois de descobrir as alterações nos dados, eles serão exibidos na interface. Um princípio do design orientado a objetos é que cada classe no sistema se concentrará em uma função, não em outros aspectos. Uma pessoa faz apenas uma coisa e faz bem. O modo de observador atrai limites claros entre os módulos, melhorando a manutenção e a reutilização do aplicativo.
O padrão de design do observador define uma dependência de um para muitos entre os objetos, para que, quando o estado de um objeto mude, todos os objetos que dependem dele sejam notificados e atualizados automaticamente.
Método de implementação:
Existem muitas maneiras de implementar o padrão do observador e, fundamentalmente, o padrão deve conter duas funções: o observador e o objeto que está sendo observado. No exemplo agora, os dados comerciais são o objeto a ser observado e a interface do usuário é o observador. Existe uma relação lógica entre o observador e o observador. Quando o observador mudar, o observador observará essas alterações e responde de acordo. Se esse processo de observação for usado entre a interface do usuário e os dados da empresa, pode -se garantir que o limite entre a interface e os dados seja desenhado. Supondo que as necessidades do aplicativo mudem, o desempenho da interface precisa ser modificado. Somente uma interface do usuário precisa ser reconstruída e os dados comerciais não precisam alterar.
1. Observador
(Observer) se registra no assunto, e o objeto observado armazena o observador em um contêiner.
2. Sendo observado
O objeto observado tem alguma alteração (como mostrado em Somechange na figura), e todos os observadores registrados são obtidos do contêiner e notificaram o observador da mudança.
3. Revogar a observação
O observador diz ao observador para cancelar a observação e remove o observador do contêiner.
Quando um observador se registra no contêiner do observador, o observador não deve perguntar sobre o tipo específico do observador, mas deve usar a interface do observador. Essa vantagem é: assumindo que existem outros observadores no programa, desde que esse observador também seja implementado pela mesma interface. Uma pessoa observada pode corresponder a vários observadores. Quando a pessoa que está sendo observada muda, ele pode notificar todos os observadores um por um. Com base em interfaces, não implementações específicas - isso fornece maior flexibilidade para os programas.
Código de demonstração:
Defina a classe abstrata a ser observada:
pacote test.edu.mainRole; importar java.util.arraylist; classe abstrata public absrole {private ArrayList <Iobserver> list = new ArrayList <Iobserver> (); public void add (iobserver observador) {list.add (observador); } public void Delete (iobserver observador) {list.remove (observador); } public void NodifyObServers (String NewState) {for (IOBServer Observer: list) {Observer.Update (NewState); }}} Papel observado Subclasse:
pacote test.edu.mainRole; A função de classe pública estende o Absrole {private string state; public String getState () {Return State; } public void alteração (string nupdate) {state = nupdate; this.nodifyObservers (estado); }} Defina a interface do observador:
pacote test.edu.mainRole; interface pública iobserver {public void update (string newState); } Observadores específicos:
pacote test.edu.mainRole; classe pública Observerobj1 implementa o iobserver {private string observerstate; @Override public void update (State String) {observerstate = state; System.out.println ("O status do Observer 1 é:" + Observerstate); }} pacote test.edu.mainRole; classe pública ObserveroBJ2 implementa o iobserver {private string observadorverstate; @Override public void update (State String) {observerstate = state; System.out.println ("O status do Observer 2 é:" + Observerstate); }} Cliente de teste:
pacote test.edu.mainRole; public class cliente { / ** * @param args * / public static void main (string [] args) {função sujeito = new função (); Iobserver observador1 = new Observerobj1 (); Iobserver observador2 = new Observerobj2 (); sujeito.Add (Observer1); sujeito.add (Observer2); sujeito.Change ("Atualização!"); }} Resultados em execução:
O estado do observador 1 é: atualização! O estado do Observer 2 é: atualização!
O exposto acima é tudo sobre este artigo, e espero que ele o inspire a aprender.