##
UTILIZAR OBSERVADOR Y OBSERVABLE

Vamos a describir en los siguientes apartados, como crear una nueva clase Observable y una nueva clase Observer y como utilizar las dos conjuntamente.

### Extender un Observable

Una nueva clase de objetos observables se crea extendiendo la clase Observable. Como la clase Observable ya implementa todos los métodos necesarios para proporcionar el funcionamiento de tipo Observador/Observable, la clase derivada solamente necesita proporcionar algún tipo de mecanismo que lo ajuste a su funcionamiento particular y proporcionar acceso al estado interno del objeto Observable.

En la clase ValorObservable que mostramos a continuación, el estado interno del Modelo es capturado en el entero `n`. A este valor se accede (y más importante todavía, se modifica) solamente a través de sus métodos públicos. Si el valor cambia, el objeto invoca a su propio método setChanged() para indicar que el estado del Modelo ha cambiado. Luego, invoca a su propio método notifyObservers() para actualizar a todos los observadores registrados.

    import java.util.Observable;

    public class ValorObservable extends Observable {
        private int nValor = 0;

        // Constructor al que indicamos el valor en que comenzamos y los
        // limites inferior y superior que no deben sobrepasarse
        public ValorObservable( int nValor,int nInferior,int nSuperior ) {
           this.nValor = nValor;
           }

        // Fija el valor que le pasamos y notifica a los observadores que
        // estan pendientes del cambio de estado de los objetos de esta
        // clase, que su etado se ha visto alterado
        public void setValor(int nValor) {
           this.nValor = nValor;

           setChanged();
           notifyObservers();
           }

        // Devuelve el valor actual que tiene el objeto
        public int getValor() {
           return( nValor );
           }
        }

### Implementar un Observador

Una nueva clase de objetos que observe los cambios en el estado de otro objeto se puede crear implementando la interface Observer. Esta interface necesita un método update() que se debe proporcionar en la nueva clase. Este método será llamado siempre que el Observable cambie de estado, que anuncia este cambio llamando a su método notifyObservers(). El observador entonces, debería interrogar al objeto Observable para determinar su nuevo estado; y, en el caso de la arquitectura MVC, ajustar su Vista adecuadamente.

En la clase ObservadorDeTexto, que muestra el código siguiente, el método notify() primero realiza una comprobación para asegurarse de que el Observable que ha anunciado un cambio es el Observable que él esta observando. Si lo es, entonces lee su estado e imprime el nuevo valor.

    import java.util.Observer;
    import java.util.Observable;

    public class TextoObservador extends Frame implements Observer {
        private ValorObservable vo = null;

        public TextoObservador( ValorObservable vo ) {
            this.vo = vo;
            }

        public void update( Observable obs,Object obj ) {
            if( obs == vo )
                tf.setText( String.valueOf( vo.getValor() ) );
            }
        }

### Usando Observador y Observable

Un programa indica a un objeto Observable que hay un objeto observador que debe ser notificado cuando se produzca un cambio en su estado, llamando al método addObserver() del objeto Observable. Este método añade el Observador a la lista de observadores que el objeto Observable ha de notificar cuando su estado se altere.

En el ejemplo siguiente, en donde mostramos la clase ControlValor, ControlValor.java, vemos como se usa el método addObserver() para añadir una instancia de la clase TextoObservador a la lista que mantiene la clase ValorObservable.

    public class ControlValor {

        // Constructor de la clase que nos permite crear los objetos de
        // observador y observable
        public ControlValor() {
            ValorObservable vo = new ValorObservable( 100,0,500 );
            TextoObservador to = new TextoObservador( vo );

            vo.addObserver( to );
            }

        public static void main( String args[] ) {
            ControlValor m = new ControlValor();
            }
        }

En la siguiente secuencia, vamos a describir como se realiza la interacción entre un Observador y un objeto Observable, durante la ejecución de un programa:

1. En primer lugar el usuario manipula un elemento del interface de usuario representado por el Controlador. Este Controlador realiza un cambio en el Modelo a través de uno de sus métodos públicos de acceso; en nuestro caso, llama a setValue().
2. El método público de acceso modifica el dato privado, ajusta el estado interno del Modelo y llama al método setChanged() para indicar que su estado ha cambiado. Luego llama al método notifyObservers() para notificar a los observadores que su estado no es el mismo. La llamada a este método puede realizarse en cualquier lugar, incluso desde un bucle de actualización que se esté ejecutando en otro thread.
3. Se llama a los métodos update() de cada Observador, indicando que hay un cambio en el estado del objeto que estaban observando. El Observador accede entonces a los datos del Modelo a través del método público del Observable y actualiza las Vistas.

|  | ##### [Anterior] [Indice] [Siguiente]