Java.util.Observable class in Java

java.util.Observable is used to create subclasses that other parts of the program can observe. When an object of such subclass undergoes a change, observing classes are notified. The update( ) method is called when an observer is notified of a change.

Note: Observing class must implement the Observer interface, which defines the update( ) method.

An object that is being observed must follow two simple rules :

1. If it is changed, it must call setChanged( ) method.
2. When it is ready to notify observers of this change, it must call notifyObservers( ) method. This causes the update( ) method in the observing object(s) to be called.

Be careful, if the object calls notifyObservers( ) method without having previously called
setChanged( ) method, no action will take place.

The observed object must call both setChanged( ) and notifyObservers( ) method, before update( ) will be called.
Constructor of java.util.Observable :

• Observable( )
  Construct an Observable with zero Observers.

Methods:

1. addObserver(Observer observer) : Adds observer to the list of objects observing the invoking object.

   Syntax : public void addObserver(Observer observer)
   Exception : NullPointerException -> if the parameter observer is null
   

   
   

   
   
   

   // Java code to demonstrate addObserver() method import java.util.*;    // This is the observer class Observer1 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer1 is added");     } }    // This is class being observed class BeingObserved extends Observable {     void incre()      {         setChanged();         notifyObservers();     } }    class ObserverDemo {     // Driver method of the program     public static void main(String args[])      {         BeingObserved beingObserved = new BeingObserved();         Observer1 observer1 = new Observer1();         beingObserved.addObserver(observer1);         beingObserved.incre();     } }

   Output :

   Observer1 is added

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

   Syntax : protected void setChanged( )
   Exception : NA.
   

   
   

   
   
   

   // Java code to demonstrate setChanged() method import java.util.*;    // This is first observer class Observer1 implements Observer {     public void update(Observable obj, Object arg) { } }    // This is class being observed class BeingObserved extends Observable {     void func1()     {         setChanged();         System.out.println("Change status with setChanged :" + hasChanged());         notifyObservers();     }            void func2()     {         System.out.println("Change status without setChanged :" + hasChanged());         notifyObservers();     } }    class ObserverDemo {     // Driver method of the program     public static void main(String args[])      {         boolean status;         BeingObserved beingObserved = new BeingObserved();         Observer1 observer1 = new Observer1();         beingObserved.addObserver(observer1);         beingObserved.func1();         beingObserved.func2();     } }

   Output :

   Change status with setChanged :true
   Change status without setChanged :false

3. clearChanged(): Indicates that this object has no longer changed, or that it has already notified all of its observers of its most recent change, so that the hasChanged( ) method will now return false.

   Syntax : protected void clearChanged( )
   Exception : NA
   

   
   

   
   
   

   // Java code to demonstrate clearChanged() method import java.util.*;    // This is the observer class Observer1 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Inside Observer1");     } }    // This is the class being observed class BeingObserved extends Observable {     void func1()     {         setChanged();         // clearChanged method removes all the changes made by setChanged method         clearChanged();         notifyObservers();                } }    class ObserverDemo { // Driver method of the program     public static void main(String args[])      {         BeingObserved beingObserved = new BeingObserved();         Observer1 observer1 = new Observer1();         beingObserved.addObserver(observer1);         beingObserved.func1();     } }

   Output :

   No Output

   No output is obtained because clearChanged( ) method has removed all the changes.

4. 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( ).

   Syntax : public void notifyObservers( )
   Exception : NA
   

   
   

   
   
   

   // Java code to demonstrate notifyObservers( ) method import java.util.*;     // This is first observer class Observer1 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer1 Notified");     } }    // This is second observer class Observer2 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer2 Notified");     } }    // This is class being observed class BeingObserved extends Observable {     void func1()     {         setChanged();         /*This method notifies the change to all the          observers that are registered*/         notifyObservers();                } }    class ObserverDemo {     // Driver method of the program     public static void main(String args[])      {         BeingObserved beingObserved = new BeingObserved();         Observer1 observer1 = new Observer1();         Observer2 observer2 = new Observer2();         beingObserved.addObserver(observer1);         beingObserved.addObserver(observer2);         beingObserved.func1();     } }

   Output :

   Observer2 Notified
   Observer1 Notified

5. 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( ).

   Syntax : public void notifyObservers(Object obj)
   Exception : NA
   

   
   

   
   
   

   // Java code to demonstrate notifyObservers(Object obj) method import java.util.*;    // This is first observer class Observer1 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer1 Notified with value : " +                  ((Integer)arg).intValue());     } }    // This is second observer class Observer2 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer2 Notified with value : " +                  ((Integer)arg).intValue());     } }    // This is class being observed class BeingObserved extends Observable {     void func1()     {         setChanged();         /*This method notifies the change to all the          observers that are registered and passes an object*/         notifyObservers(new Integer(10));                } }    class ObserverDemo {     // Driver method of the program     public static void main(String args[])      {         BeingObserved beingObserved = new BeingObserved();         Observer1 observer1 = new Observer1();         Observer2 observer2 = new Observer2();         beingObserved.addObserver(observer1);         beingObserved.addObserver(observer2);         beingObserved.func1();     } }

   Output :

   Observer2 Notified with value : 10
   Observer1 Notified with value : 10

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

   Syntax : public int countObservers( )
   Returns : the number of observers of this object
   Exception : NA
   

   
   

   
   
   

   // Java code to demonstrate countObservers() method import java.util.*;    // This is first observer class Observer1 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer1");     } }    // This is second observer class Observer2 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer2");     } }    // This is class being observed class BeingObserved extends Observable {     void func1()     {         setChanged();         notifyObservers();     } }    class ObserverDemo {     // Driver method of the program     public static void main(String args[])      {         BeingObserved beingObserved = new BeingObserved();         Observer1 observer1 = new Observer1();         Observer2 observer2 = new Observer2();         beingObserved.addObserver(observer1);         beingObserved.addObserver(observer2);         int count_observer = beingObserved.countObservers();         System.out.println("Number of observers is " + count_observer);         beingObserved.func1();     } }

   Output :

   Number of observers is 2
   Observer2
   Observer1

7. deleteObserver(Observer observer): Removes observer from the list of objects observing the invoking object.
   Passing null to this method will have no effect.

   Syntax : public void deleteObserver(Observer observer)
   Exception : NA
   

   
   

   
   
   

   // Java code to demonstrate deleteObserver(Observer observer) method import java.util.*;    // This is first observer class Observer1 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer1");     } }    // This is second observer class Observer2 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer2");     } }    // This is class being observed class BeingObserved extends Observable {     void func1()     {         setChanged();         notifyObservers();     } }    class ObserverDemo {     // Driver method of the program     public static void main(String args[])      {         int count_observer;         BeingObserved beingObserved = new BeingObserved();         Observer1 observer1 = new Observer1();         Observer2 observer2 = new Observer2();         beingObserved.addObserver(observer1);         beingObserved.addObserver(observer2);                    count_observer = beingObserved.countObservers();         System.out.println("Number of observers before" +          " calling deleteObserver(): " + count_observer);         beingObserved.func1();                    // Deleting observer1         beingObserved.deleteObserver(observer1);         count_observer = beingObserved.countObservers();         System.out.println("No. of observers after"+          " calling deleteObserver(): " + count_observer);         beingObserved.func1();                } }

   Output :

   Number of observers before calling deleteObserver(): 2
   Observer2
   Observer1
   No. of observers aftercalling deleteObserver(): 1
   Observer2

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

   Syntax : public void deleteObservers()
   Exception : NA
   

   
   

   
   
   

   // Java code to demonstrate deleteObservers() method import java.util.*;    // This is first observer class Observer1 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer1");     } }    // This is second observer class Observer2 implements Observer {     public void update(Observable obj, Object arg)      {         System.out.println("Observer2");     } }    // This is class being observed class BeingObserved extends Observable {     void func1()     {         setChanged();         notifyObservers(new Integer(10));     } }    class ObserverDemo {     // Driver method of the program     public static void main(String args[])      {         int count_observer;         BeingObserved beingObserved = new BeingObserved();         Observer1 observer1 = new Observer1();         Observer2 observer2 = new Observer2();         beingObserved.addObserver(observer1);         beingObserved.addObserver(observer2);                    count_observer = beingObserved.countObservers();         System.out.println("Number of observers before" +          " calling deleteObserver(): " + count_observer);         beingObserved.func1();                    // Deleting all observers         beingObserved.deleteObservers();         count_observer = beingObserved.countObservers();         System.out.println("No. of observers after "+          "calling deleteObserver(): " + count_observer);         beingObserved.func1();                } }

   Output :

   Number of observers before calling deleteObserver(): 2
   Observer2
   Observer1
   No. of observers after calling deleteObserver(): 0

Ref: Observables in Java

This article is contributed by Dipak Chouhan. If you like Lazyroar and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the Lazyroar main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.