java.util.Observable is a class in Java used to implement the Observer design pattern.
It allows an object (observable) to maintain a list of dependents (observers) that are automatically notified of any changes in its state.
Note: Observable is marked deprecated since Java 9 in favor of more flexible and customizable solutions like java.beans or third-party libraries like RxJava.
Commonly Used Constructors and Methods
Simple Program – Observable and Observer
import java.util.Observable;
import java.util.Observer;
class NewsAgency extends Observable {
void setNews(String news) {
setChanged();
notifyObservers(news);
}
}
class Subscriber implements Observer {
private String name;
public Subscriber(String name) {
this.name = name;
}
public void update(Observable o, Object arg) {
System.out.println(name + " received update: " + arg);
}
}
public class SimpleObservableDemo {
public static void main(String[] args) {
NewsAgency agency = new NewsAgency();
Subscriber s1 = new Subscriber("Paani");
Subscriber s2 = new Subscriber("Mahesh");
agency.addObserver(s1);
agency.addObserver(s2);
agency.setNews("Java 21 Released!");
}
}Paani received update: Java 21 Released!
Mahesh received update: Java 21 Released!Problem Statement:
LotusJavaPrince builds a banking alert system.Mahesh subscribes to notifications like Balance Alerts, Deposit Alerts, and Loan Updates.Every time a banking event occurs, all subscribed observers should be notified automatically.
import java.util.Observable;
import java.util.Observer;
// Observable class
class BankNotificationCenter extends Observable {
void sendAlert(String alert) {
setChanged();
notifyObservers(alert);
}
}
// Observer classes
class BalanceObserver implements Observer {
public void update(Observable o, Object arg) {
System.out.println("Balance Alert → " + arg);
}
}
class DepositObserver implements Observer {
public void update(Observable o, Object arg) {
System.out.println("Deposit Alert → " + arg);
}
}
class LoanObserver implements Observer {
public void update(Observable o, Object arg) {
System.out.println("Loan Alert → " + arg);
}
}
public class BankAlertSystem {
public static void main(String[] args) {
// Observable instance
BankNotificationCenter center = new BankNotificationCenter();
// Observers
BalanceObserver balance = new BalanceObserver();
DepositObserver deposit = new DepositObserver();
LoanObserver loan = new LoanObserver();
// Register observers
center.addObserver(balance);
center.addObserver(deposit);
center.addObserver(loan);
// Trigger events
center.sendAlert("Mahesh's balance dropped below ₹500.");
center.sendAlert("LotusJavaPrince received a deposit of ₹10,000.");
center.sendAlert("Loan EMI due for Mahesh.");
}
}
Observable simplifies the publish-subscribe model.Observers are automatically notified when the state changes.Enables loose coupling between subject and observers.Suitable for event-driven applications (e.g., alerting, GUI, messaging).
Though useful, Observable is deprecated in modern Java because:
- It’s a class (not an interface), so it’s inflexible.
- Doesn’t support lambda expressions.
- Modern alternatives include JavaFX Observable,Java Flow API (Reactive Streams),RxJava / Project Reactor
- Â