Patrones de Diseño

PATRON OBSERVADOR
Sujeto (Subject):
El sujeto concreto proporciona una interfaz para agregar (attach) y eliminar (detach) observadores. El Sujeto conoce a todos sus observadores.
Observador (Observer):
Define el método que usa el sujeto para notificar cambios en su estado (update/notify).
Sujeto Concreto (ConcreteSubject):
Mantiene el estado de interés para los observadores concretos ylos notifica cuando cambia su estado. No tienen porque ser elementos de la misma jerarquía.
Observador Concreto (ConcreteObserver):
Mantiene una referencia al sujeto concreto e implementa la interfaz de actualización, es decir, guardan la referencia del objeto que observan, así en caso de ser notificados de algún cambio, pueden preguntar sobre este cambio.
/*Esta clase abstracta representalos objetos susceptibles de ser
*observados. Incorpora metodos para agregar y eliminar observadores
*y un metodo de notificacion. La asociacion Observable-Observadores
*se implementa mediante un vector de observadores
*/

import java.util.ArrayList;

public abstract class Observable {

//El constructor crea el vector con la asociacion Observable-Observador
publicObservable() {
_observadores = new ArrayList();
}

//Agregar y eliminar sencillamente operan sobre vector _observadores...
public void agregarObservador(Observador o) {
_observadores.add(o);
}

public void eliminarObservador(Observador o) {
_observadores.remove(o);
}

//Notificacion: Para cada observador se invoca el método actualizar().public void notificarObservadores() {
for (Observador o:_observadores) {
o.actualizar();
}
}

//Este atributo privado mantiene el vector con los observadores
private ArrayList _observadores;
}

/*Los observadores deben implementar la siguiente interfaz, es decir,
*tienen un metodo actualizar() para reaccionar a cambios del sujeto
*/
publicinterface Observador {
public void actualizar();
}

/*Ejemplo de sujeto observable. Es una clase que mantiene un valor entero en
*el rango 0..maximo, donde maximo se establece en la construccion. La clase
*dispone de metodos para modificar el valor y para acceder al estado
*(valor, maximo). Extiende la clase observable heredando su
*/

public class Contador extends Observable {/*El constructor inicializa el estado del objeto: el maximo y el
*valor inicial, siempre en el rango 0..maximo. Adicionalmente,
*inicializa la parte de Observable que tiene un Contador...
*/
public Contador(int valor, int maximo) {
super();
_maximo = maximo;
_valor = enRango(valor);
}

//Este metodo privado asegura que un valor n estaentre 0..maximo
private int enRango(int n) {
if (n < 0) {
return 0;
} else if (n > _maximo) {
return _maximo;
} else {
return n;
}
}

//Estos dos metodos permiten el acceso al estado del contador
public int valor() {
return _valor;
}

public int maximo() {
return _maximo;}

/*Este metodo afecta al estado: primero se modifica de forma consistente
*el estado y despues se notifica a los observadores del cambio
*/
public void incrementarContador(int n) {
_valor = enRango(_valor+n);
notificarObservadores();
}

//Atributos privados que mantienen el estado del contador
private int _valor, _maximo;
}


//Observador muy simple que ni siquiera consulta el estado del sujeto...

public class Detector implements Observador {

public void actualizar() {
System.out.println("Detector recibe actualizar!");
}

}

//Un ejemplo de observador concreto de la clase contador.

public class Medidor implements Observador {

//El constructor de Medidor establece la asociacion...