In Java, the Observable class is used to create objects that can be observed by other parts of the program. When an object of such a subclass undergoes a change, observing classes are notified. The update() method is called when an observer is notified of a change.
Note: The Observable class and Observer interface are deprecated in Java 9.
Key Concepts:
An object that is being observed must follow two basic rules:
- The Observed Object:
- If it is changed, it must call the setChanged() method.
- When it is ready to notify observers of this change, it must call the notifyObservers() method. This triggers the the method in the observer objects.
Note: Be careful, if the object calls the notifyObservers() method without having previously called the setChanged() method, no action will take place.
- The Observer Class:
- The observer class implements the Observer interface and must override the update() method.
Constructors in Observable Class
This class consists of one constructor, with the help of which we can create objects of this class.
1. Observable( ): Construct an Observable with zero Observers.
Syntax:
Observable( )
Java Observable Methods
Now, we are going to discuss each method one by one in detail:
1. addObserver(Observer observer): Adds observer to the list of objects observing the invoking object.
Syntax:
public void addObserver(Observer observer)
- Parameter: This method take single parameter Observer observer, which is an object that will notify for any changes.
- Return Type: This method does not return anything.
Example:
Java
// Java program to demonstrate
// the working of 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 Geeks{
// Driver method of the program
public static void main(String args[])
{
BeingObserved beingObserved = new BeingObserved();
Observer1 o1 = new Observer1();
beingObserved.addObserver(o1);
beingObserved.incre();
}
}
2. setChanged(): This method is used to marks the invoking object as changed.
Syntax:
protected void setChanged()
- Parameter: This method does not return anything.
- Return Type: This method does not take any parameter.
Note: Once setChanged() is called, the object let itsw observer know that something has changed.
Example:
Java
// Java program to demonstrates
// the working of 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 Geeks {
// Driver method of the program
public static void main(String args[])
{
boolean status;
BeingObserved bo = new BeingObserved();
Observer1 o = new Observer1();
bo.addObserver(o);
bo.func1();
bo.func2();
}
}
OutputChange 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( )
- Parameter: This method does not take any parameter
- Return Type: This method does not return anything.
Example:
Java
// Java program to demonstrates the
// working of 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 Geeks {
// Driver method of the program
public static void main(String args[])
{
BeingObserved bo = new BeingObserved();
Observer1 o1 = new Observer1();
bo.addObserver(o1);
bo.func1();
}
}
Output:
No Output
Note: 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( )
- Parameter: This method does not take any parameter.
- Return Type: This method does not return anything.
Example:
Java
// Java program to demonstrates
// the working of 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 Geeks {
// Driver method of the program
public static void main(String args[])
{
BeingObserved bo = new BeingObserved();
Observer1 o1 = new Observer1();
Observer2 o2 = new Observer2();
bo.addObserver(o1);
bo.addObserver(o2);
bo.func1();
}
}
OutputObserver2 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)
- Parameter: This method does not take any parameter.
- Return Type: This method does not return anything.
Example:
Java
// Java program to demonstrate the working of
// 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();
// Using Integer.valueOf
notifyObservers(Integer.valueOf(10));
}
}
class Geeks {
// Driver method of the program
public static void main(String args[]) {
BeingObserved bo = new BeingObserved();
Observer1 observer1 = new Observer1();
Observer2 observer2 = new Observer2();
bo.addObserver(observer1);
// Corrected variable name
bo.addObserver(observer2);
// Calling func1 on the correct object
bo.func1();
}
}
OutputObserver2 Notified with value: 10
Observer1 Notified with value: 10
6. countObservers(): Returns the number of objects observing the invoking object.
Syntax:
public int countObservers( )
- Parameter: This method does not take any parameter.
- Return Type: This method returns the number of observers currently observing the object.
Example:
Java
// Java program to demonstrates the
// working of 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 Geeks{
// Driver method of the program
public static void main(String args[])
{
BeingObserved bo = new BeingObserved();
Observer1 o1 = new Observer1();
Observer2 o2 = new Observer2();
bo.addObserver(o1);
bo.addObserver(o2);
int count_observer = bo.countObservers();
System.out.println("Number of observers is "
+ count_observer);
bo.func1();
}
}
OutputNumber 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)
- Parameter: This method does not take any parameter.
- Return Type: This method does not return anything.
Example:
Java
// Java code to demonstrate the working of
// 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 Geeks {
// Driver method of the program
public static void main(String args[])
{
int c;
BeingObserved bo = new BeingObserved();
Observer1 observer1 = new Observer1();
Observer2 observer2 = new Observer2();
bo.addObserver(observer1);
bo.addObserver(observer2);
c = bo.countObservers();
System.out.println("Number of observers before" +
" calling deleteObserver(): " + c);
bo.func1();
// Deleting observer1
bo.deleteObserver(observer1);
c = bo.countObservers();
System.out.println("No. of observers after"+
" calling deleteObserver(): " + c);
bo.func1();
}
}
OutputNumber of observers before calling deleteObserver(): 2
Observer2
Observer1
No. of observers after calling deleteObserver(): 1
Observer2
8. deleteObservers(): Removes all observers for the invoking object.
Syntax:
public void deleteObservers()
- Parameter: This method does not take any parameter.
- Return Type: This method does not return anything.
Example:
Java
// Java program to demonstrates the
// working of 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( Integer.valueOf(10));
}
}
class Geeks {
// Driver method of the program
public static void main(String args[])
{
int c;
BeingObserved bo = new BeingObserved();
Observer1 o1 = new Observer1();
Observer2 o2 = new Observer2();
bo.addObserver(o1);
bo.addObserver(o2);
c = bo.countObservers();
System.out.println("Number of observers before" +
" calling deleteObserver(): " + c);
bo.func1();
// Deleting all observers
bo.deleteObservers();
c = bo.countObservers();
System.out.println("No. of observers after "+
"calling deleteObserver(): " + c);
bo.func1();
}
}
OutputNumber of observers before calling deleteObserver(): 2
Observer2
Observer1
No. of observers after calling deleteObserver(): 0
Similar Reads
Java.util.Observable class in Java
In Java, the Observable class is used to create objects that can be observed by other parts of the program. When an object of such a subclass undergoes a change, observing classes are notified. The update() method is called when an observer is notified of a change. Note: The Observable class and Obs
8 min read
Java Reader Class
Reader class in Java is an abstract class used for reading character streams. It serves as the base class for various subclasses like FileReader, BufferedReader, CharArrayReader, and others, which provide more efficient implementations of the read() method. To work with the Reader class, we must ext
7 min read
Java ServerSocket Class
ServerSocket Class in Java provides a system-independent way to implement the server side of a client/server socket connection. The constructor for ServerSocket throws an exception if it can’t listen on the specified port (for example, the port is already being used). In the java.nio channel, Server
4 min read
JavaBean class in Java
JavaBeans are classes that encapsulate many objects into a single object (the bean). It is a Java class that should follow the following conventions: Must implement Serializable.It should have a public no-arg constructor.All properties in java bean must be private with public getters and setter meth
3 min read
Java Writer Class
Java writer class is an abstract class in the java.io package. It is designed for writing character streams. Writer class in Java provides methods for writing characters, arrays of characters, and strings. Since it is an abstract class, we cannot create an instance of it directly. Instead, we will u
5 min read
Wrapper Classes in Java
A Wrapper class in Java is one whose object wraps or contains primitive data types. When we create an object in a wrapper class, it contains a field, and in this field, we can store primitive data types. In other words, we can wrap a primitive value into a wrapper class object. Let's check on the wr
6 min read
Static class in Java
Java allows a class to be defined within another class. These are called Nested Classes. Classes can be static which most developers are aware of, henceforth some classes can be made static in Java. Java supports Static Instance Variables, Static Methods, Static Block, and Static Classes. The class
3 min read
JavaFX | Popup Class
Popup class is a part of JavaFX. Popup class creates a popup with no content, a null fill and is transparent. Popup class is used to display a notification, buttons, or a drop-down menu and so forth. The popup has no decorations. It essentially acts as a specialized scene/window which has no decorat
4 min read
Scope of Variables in Java
The scope of variables is the part of the program where the variable is accessible. Like C/C++, in Java, all identifiers are lexically (or statically) scoped, i.e. scope of a variable can be determined at compile time and independent of the function call stack. In this article, we will learn about J
6 min read
Classes and Objects in Java
In Java, classes and objects are basic concepts of Object Oriented Programming (OOPs) that are used to represent real-world concepts and entities. The class represents a group of objects having similar properties and behavior, or in other words, we can say that a class is a blueprint for objects, wh
12 min read