Bienvenidos.
Continuamos con el patrón Observer, observador en español.
Es un patrón de diseño que define una dependencia entre objeto de uno a muchos.
Cuando el objeto principal dice que se está observando, cambia su estado, notificÃ, te cambio a todos
sus objetos dependientes de forma automática.
Los sujetos dependientes son los observadores.
El que cambia el estado y que están escuchando están pendiente.
Los observadores es el sujeto.
Se le conoce como sujeto o observable quien está siendo observado.
Por eso se le conoce como observable.
Es un patrón de diseño del tipo comportamiento, pero también estructural por las relaciones entre objetos
o clases, pero también de comportamiento porque define el cómo se comunican entre ellos.
Bien, veamos el ir a una clase.
Acá tenemos el sujeto que se le conoce como observable y los observadores son varios.
Un sujeto puede agregar varios observadores, por eso tiene el método agregar o añadir, eliminar y
notificar, mientras que el observador realmente está escuchando.
Está pendiente que algo suceda en el sujeto cuando cambia algún estado.
El estado sería el valor de algún atributo importante que se está monitoreando.
Entonces cambia este valor automáticamente se notifica.
Por eso tiene método notificar a todos los observadores que están suscrito.
Veamos las relaciones.
Acá tenemos el observador y acá tenemos el sujeto.
El sujeto tiene una relación de agregación acá y 10 rombo.
Pero en este diagrama está definido como cardinalidad.
Por eso el asterisco.
Es decir, el sujeto contiene muchos observadores n por eso asterisco.
Acá tenemos unos de valor concreto.
El observador podría ser una clase abstracta o una interfaz y lo vimos sujeto.
Bueno, en realidad el sujeto observable más que una interfaz, debería ser una clase padre abstracta
con los sujetos concretos que heredan y reutilizan algunos melos, como notificar, agregar, eliminar.
En fin, iba a tener el Estado el Estado cuando cambia.
Por eso acá tiene el atributo Estado, pero puede ser cualquier atributo de lo mismo.
No se tiene porque llamar estado cuando cambia, notifica.
De hecho, si nos vamos al ejemplo en inglés, el diagrama está un poco mejor.
Acá el subject observable que contiene una colección.
Por eso acá está el rombo, tiene varios observadores y los observadores no se notificado cuando pase
algo acá.
Y otro tema importante que el observador va a tener.
El método APDAYC para que sea notificado.
Quién mejor que un ejemplo para que lo podemos visualizar?
Cerramos todo.
Vamos a crear un pacato.
Observás?
Bien, vamos a partir primero definiendo la interfaz Observer para los observadores.
Interfax Obsérvelo.
Bien, una interfaz va a tener un método que le vamos a llamar APDAYC, mismo nombre que el patrón que
define el patrón en español, sería como actualizar.
No devuelve nada.
Solamente realiza alguna acción, alguna tarea, algo.
Cuando son notificados y va a recibir por argumento una instancia del objeto observable que cambió su
estado.
No se preocupen, la clase todavía no existe.
No vayan a importar, porque también existe la clase observable de Java útil, pero de pruébatela.
Entonces esta clase la vamos a crear observable hops de observable o le ponemos observable.
Listo.
Ahí tenemos.
Bien, vamos a crear esta clase observable.
De hecho, voy a copiar el nombre y la vamos a pegar acá.
Yo tenía una clase, no una interfaz, una clase abstracta.
Entonces por acá, abstracto.
Y la vamos a implementar.
Recuerden que la relación es de un observable.
Muchos observadores protected del tipo listo, una lista observer.
Observadores observéis igual niu ArrayList.
Listo.
Vamos a importar de lleba útil.
Un public boy public voy a Server Observer observador perfecto, entonces vamos a añadir observadores,
observéis punto AB haz oh buen pcoo caro.
Mejor vamos a colocar Observer para que quede más explícito.
Observen y acá también.
B Eliminado.
Remu Lo mismo Observer
observéis la lista.
Punto.
Rimón y pasamos el objeto, observa, pero recuerden que se pue eliminar.
Tenemos que implementar el método y en las listas.
Entonces en la clase Observer.
O más que bueno, en realidad es una interfaz, pero después en la clase que implementa esta interfaz
derio implementar este método y es para qué se puede eliminar.
Bien, continuemos.
Lo segundo y el método importante del patrón es para notificar public void solamente notificar nada
más.
No devuelve nada.
Notify observer.
Notificar observadores.
Lo puedo colocar en español.
Da lo mismo, pero voy a utilizar los nombres del patrón notify observes con un for del tipo Observer
observadores 2 punto in this punto observes y por cada uno notificamos.
Entonces le invocamos el método a cada observador.
Recuerden que causa el valor por la interfaz.
Va a tener el método затем que recibe el observable.
Por lo tanto le pasamos el this add dato punto this una instancia.
Detuvimos el valor de este mismo objeto y prácticamente ya tenemos listo nuestro patrón diseño.
Solamente tenemos que implementar la clase concretas.
Vamos a crear dos ejemplos de compañías que invierten en la bolsa y tienen un precio en la bolsa de
comercio, por ejemplo.
Y cuando cambia este precio, notifica a todos los inversionistas que ha aumentado o ha bajado el precio
de forma automática.
Esa es la idea.
Entonces vamos a crear nuestra clase, compañía o corporación como la queramos llamar new yaba class
corporación corporación bien tiene que heredar de observable.
Pero recuerden, siempre importen de nuestra clase observable y no de lleba útil.
Tengan cuidado con el import siempre de nuestra clase.
Corporación va a reutilizar todo lo que tenemos en Observable, vamos a poder añadir observadores.
Entonces esta corporación, esta empresa, va a agregar inversionista.
Qué iban a hacer?
Lo que están observando, el precio.
El valor de tu compañía en la bolsa comercial bien va a tener atributos como el nombre, el precio
de lo mismo, el tipo de tipo Integer o tipo long o double.
Cómo queremos manejar, por ejemplo?
Da igual, vamos a implementar el constructor generate.
Constructor.
Los dos marcamos nombre precio OC.
Y los método nyet para cada uno.
Totalmente lo quieto generad juguetes para los dos.
Nombre precio.
Bien, el set solamente nombre y precio Vieh constructora y solamente se puede modificar el precio.
Entonces vamos a tener un método public void modifica el precio, entonces cae que se modifica el precio.
Bueno, acá recibe el nuevo precio o valor de punto precio igual el precio, pero cambia.
Notificamos cómo estamos heredando de observable.
Podemos llamar el método notify notify.
Obsérvese.
Soy virgen.
Y esa forma va a notificar a todos los observadores con el foro, uno por uno.
Entonces cree que cambia el estado de algún atributo importante y queremos notificar a los que tenemos
suscritos y enfocamos este método.
Y eso sería entonces vamos a probar el patrón.
Vamos a crear una clase ejemplo new ya class.
O mejor, un package.
Ejemplos.
Ahora sí, ejemplo Observer,
vamos a crear primero una instancia de corporación que del tipo observable corporación, por ejemplo
Google New Corporación, pasamos el nombre y el valor, por ejemplo 1000 y vamos a agregar en Google
observadoras, entonces add observer.
Pero recuerden, el observador es una implementación de la interfaz.
Podemos crear una clase, implementar este método ADAT, implementar la interfaz por supuesto y listo,
o bien usando Aprisione lanta.
Entonces acá se emite.
Recuerden, se pasa por argumento el observable entonces observable.
Implementamos el método, хотя.
Por ejemplo, Allon
mientras objeto observable, si nos vamos acá.
Acá se notifica y tenemos la corporación que hereda de este.
Y acá tenemos el nombre y el precio y pudimos mostrar esta nueva información.
Entonces para John acá notificÃ John.
Observable, obviamente no tienen método, nyet nombre ni geet precio, se fijan, no lo tiene.
Entonces habría que hacer un často.
Vamos a hacer un cast de corporación corporación, hacemos el cast.
Otro paréntesis más para invocar el método y acá observable y parentes.
Y ahora bien, nombre.
Más vamos a bajar y lo mismo vamos a copiar esto.
El cast y lo pegamos acá.
Guet precio.
Pero entre medio vamos a tener otro más, un strength nuevo precio de origen.
Entonces notificÃ John con el nuevo precio y así podríamos tener varios observadores, incluso con diferente
implementación.
Pero para el ejemplo vamos a colocar el mismo, por ejemplo, Andrés.
Acá tenemos dos inversionista y podríamos tener otro más.
Amaria.
Bueno, si lo ejecutamos, obviamente no pasa nada, de hecho vamos a levantar y no pasa nada, porque
el precio no ha cambiado, el precio se mantiene.
Cierto mvil.
Pero qué pasa si acá modificamos el precio?
Colocamos a Google.
Punto.
Modifica el precio.
Ahora vale 2000.
Actualizamos el precio.
Vamos a ver.
notificÃ John Google.
Nuevo precio.
2000 y notifica a uno por uno, a cada observador el valor.
Ahora, incluso esto mismo, para que quede más simple, lo podríamos llevar al método toString de la
clase corporación.
De hecho, vamos a cortar esto solamente.
Que mejor vamos a implementar el método toString.
Generad tu estric, ok.
Pero lo vamos a reemplazar.
Quitamos esto.
El cast no necesario, solamente que el nombre de acá.
Qué precio?
Listo, volvemos acá y acá imprimimos el objeto observable.
Y lo mismo acá.
Entonces queda mejor.
Tiene mucho más limpio y eso es el patrón.
Veamos otro ejemplo cortito, simple, de este mismo patrón para que tenga dos variantes.
Voy a cerrar acá.
Vamos a crear otra clase que variedad de observable entonces acá en Observer.
Vamos a crear otra más.
Le vamos a llamar usuario repositorio.
Entonces, cada vez que creamos un nuevo usuario en el sistema, vamos a notificar a los observadores
para que hagan distintas cosas.
Por ejemplo, que mandé un correo al usuario, otro servidor que envíe un correo al administrador del
sistema, otro que lo guarde en el log.
En fin, podríamos tener diferentes eventos cada vez que se registra un nuevo usuario
stents observable.
Vamos a tener un atributo privado del tipo list, del tipo usuario.
Pero para simplificar, vamos a registrar nombres, claro, pero de ir a hacer una clase usuario con
el nombre, apellido o el email y el campo que necesitemos.
Vamos a importar list donde lleva útil repositorio
New ArrayList.
Perfecto.
Lo estoy inicializado acá mismo como atributo.
También puede ser en el constructor.
También lo podríamos implementar en la conducta, pero que sea más simple solamente el método crear
public void crear crear usuario o crear nuevo usuario.
Acá recibe el usuario del tipo usuario, pero vamos a colocar string.
Esto podría ser la base auto perfectamente bien con Moise, uele, con Orac, con lo que sea, pero
como todavía no hemos visto, lo registramos en la lista con él.
Haddo simulando un registro en la tabla dija pasamos el usuario entonces acá que se crea un usuario
se registra en la Ayato o da lo mismo?
También puede ser para eliminar, para modificar.
Vamos a notificar.
Se fijan entonces какие cambia el estado o se ejecuta alguna tarea importante?
Notificamos acá tengo mal escrito.
Es usuario repositorio, no repositorio.
Vamos a ejemplo.
Ejemplo 2.
Con M
2.
Con el usuario repositorio.
Repositorio Tiguan New Usuario Repositorio Perfecto 12 repo punto agregar observador observador lleca
alguna tarea shout.
Enviando un email al usuario repo juntoa Observer.
Enviando un email al administrador o administradores.
Se fijan, estamos registrando distintos eventos, suscritores, observadores, para que hagan algo
cuando se registre un usuario.
Perfecto.
Bien, vamos a repo repo.
Punto agregar usuario o crear usuario.
3.
Enviando un email al usuario enviado mail administrador, guardando información del usuario erlo.
Ahora, qué pasa si quiero mostrar acá la información del usuario que se está registrando?
Porque en la clase usuario repositorio.
Acá se pasa el usuario.
Me gustaría poder pasar este usuario acá a notify observes y poder mostrar la información.
Que esté disponible, por ejemplo, no sé acá en este método.
Bueno, ahí tenemos que modificar un poco la estructura, como por ejemplo acá.
Perdón?
No, acá vamos a ir a Observable.
Acá, acá podríamos tener alguna sobrecarga de método.
Uno que no reciba argumento y otro que reciba.
Por ejemplo, vamos a tener acá Public Boy Notify
y acá pasamos un objeto o texto objeto.
Y esto mismo lo cortamos, lo pegamos, acá llega, pasamos objeto, objeto.
Ahora marca error.
Eso después lo vamos a solucionar.
Y acá tiene argumento Notify o Sergas, pero pasamos Nule se fijen los reutilizados.
Entonces notify observer sin argumento, invocaste de acá, pero le pasamos nul nada y tendría que modificar
el Abbott con doble argumento.
Para eso nos vamos a los server.
Acá le agregamos otro objeto.
Y nos vamos a ejemplo Observer.
Ahora, claro, son dos argumentos.
Acá solamente utilizamos uno, pero no los dos.
Entonces acá podríamos colocar.
Recuerden, cuando son más, colocamos paréntesis, paréntesis.
Gomá El objeto de esto y esto en cada uno.
Entonces así disponemos de ambos en este caso.
Bueno, da lo mismo en el ejemplo de corporación, ya que no estamos pasando ningún objeto.
Si nos vamos a corporación.
Acá no pasamos nada, no pasamos ningún dato que Anul.
Simplemente no utilizamos el segundo parámetro, solamente utilizamos observable, pero en el ejemplo
repositorio bueno Akashi vámonos ejemplo o server 2.
Casi de lo mismo.
Coma objeto o en este caso sería usuario u de usuario.
Y lo pegamos acá.
Enviando un email al usuario.
Enviando un email administrador por nuevo usuario y aca guardando información del usuario concatenados,
bajamos un.
Ejemplo repositorio.
Acá pasamos el usuario también en nombre de usuario importante Notify o Shermer, pasamos nombre del
usuario.
Ahora si.
Enviando un email al usuario en 3 acto el espacio.
Guardan información del usuario en 3 en el log.
Y así podríamos tener la información del objeto que se está registrando en este caso.
Nada más.
Continuamos en la siguiente clase.