Observable - java.util

Observable

The Observable class is used to create subclasses that other parts of your program can observe. When an object of such a subclass undergoes a change, observing classes are notified. Observing classes must implement the Observer interface, which defines the update( ) method. The update( ) method is called when an observer is notified of a change in an observed object.

Observable defines the methods shown in Table 19-8. An object that is being observed must follow two simple rules. First, if it has changed, it must call setChanged( ). Second, when it is ready to notify observers of this change, it must call notifyObservers( ). This causes the update( ) method in the observing object(s) to be called. Be careful—if the

Method : Description

void addObserver(Observer obj) : Adds obj to the list of objects observing the invoking object.

protected void clearChanged( ) : Calling this method returns the status of the invoking object to "unchanged."

int countObservers( ) : Returns the number of objects observing the invoking object.

void deleteObserver(Observer obj) : Removes obj from the list of objects observing the invoking object.

void deleteObservers( ) : Removes all observers for the invoking object.

boolean hasChanged( ) : Returns true if the invoking object has been modified and false if it has not.

void notifyObservers( ) : Notifies all observers of the invoking object that it has changed by calling update( ). A null is passed as the second argument to update( ).

void notifyObservers(Object obj) : Notifies all observers of the invoking object that it has changed by calling update( ). obj is passed as an argument to update( ).

protected void setChanged( ) : Called when the invoking object has changed.

Table 19-8   The Methods Defined by Observable

object calls notifyObservers( ) without having previously called setChanged( ), no action will take place. The observed object must call both setChanged( ) and notifyObservers( ) before update( ) will be called.

Notice that notifyObservers( ) has two forms: one that takes an argument and one that does not. If you call notifyObservers( ) with an argument, this object is passed to the observer’s update( ) method as its second parameter. Otherwise, null is passed to update( ). You can use the second parameter for passing any type of object that is appropriate for your application.

The Observer Interface

To observe an observable object, you must implement the Observer interface. This interface defines only the one method shown here:

void update(Observable observOb, Object arg)

Here, observOb is the object being observed, and arg is the value passed by notifyObservers( ). The update( ) method is called when a change in the observed object takes place.

An Observer Example

Here is an example that demonstrates an observable object. It creates an observer class, called Watcher, that implements the Observer interface. The class being monitored is called BeingWatched. It extends Observable. Inside BeingWatched is the method counter( ), which simply counts down from a specified value. It uses sleep( ) to wait a tenth of a second between counts. Each time the count changes, notifyObservers( ) is called with the current count passed as its argument. This causes the update( ) method inside Watcher to be called, which displays the current count. Inside main( ), a Watcher and a BeingWatched object, called observing and observed, respectively, are created. Then, observing is added to the list of observers for observed. This means that observing.update( ) will be called each time counter( ) calls notifyObservers( ).

/*    Demonstrate the Observable class and the Observer interface.

*/

import java.util.*;

// This is the observing class.

class Watcher implements Observer {

public void update(Observable obj, Object arg) { System.out.println("update() called, count is " +

((Integer)arg).intValue());

}

}

// This is the class being observed.

class BeingWatched extends Observable {

void counter(int period) {

for( ; period >=0; period--) { setChanged();

notifyObservers(new Integer(period));

try { Thread.sleep(100);

} catch(InterruptedException e) { System.out.println("Sleep interrupted");

}

}

}

}

class ObserverDemo {

public static void main(String args[]) {

BeingWatched observed = new BeingWatched();

Watcher observing = new Watcher();

/* Add the observing to the list of observers for observed object. */

observed.addObserver(observing);

observed.counter(10);

}

}

The output from this program is shown here:

update() called, count is 10 update() called, count is 9 update() called, count is 8 update() called, count is 7 update() called, count is 6 update() called, count is 5 update() called, count is 4 update() called, count is 3 update() called, count is 2 update() called, count is 1 update() called, count is 0

More than one object can be an observer. For example, the following program implements two observing classes and adds an object of each class to the BeingWatched observer list. The second observer waits until the count reaches zero and then rings the bell.

/*       An object may be observed by two or more observers.

*/

import java.util.*;

// This is the first observing class.

class Watcher1 implements Observer {

public void update(Observable obj, Object arg) {

System.out.println("update() called, count is " +

((Integer)arg).intValue());

}

}

// This is the second observing class.

class Watcher2 implements Observer {

public void update(Observable obj, Object arg) {

// Ring bell when done

if(((Integer)arg).intValue() == 0)

System.out.println("Done" + '\7');

}

}

// This is the class being observed.

class BeingWatched extends Observable {

void counter(int period) {

for( ; period >=0; period--) { setChanged();

notifyObservers(new Integer(period)); try {

Thread.sleep(100);

} catch(InterruptedException e) {

System.out.println("Sleep interrupted");

}

}

}

}

class TwoObservers {

public static void main(String args[]) {

BeingWatched observed = new BeingWatched();

Watcher1 observing1 = new Watcher1();

Watcher2 observing2 = new Watcher2();

// add both observers

observed.addObserver(observing1); observed.addObserver(observing2);

observed.counter(10);

}

}

The Observable class and the Observer interface allow you to implement sophisticated program architectures based on the document/view methodology.