java.util.Observable

By / 27 May 2025 / 2 minutes of reading

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
  •  

Related Posts

Scroll to Top