Open In App

Java.util.Observable class in Java

Improve
Improve
Like Article
Like
Save
Share
Report

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



Last Updated : 08 Jul, 2017
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads