The Observer Design Pattern is a behavioral design pattern that defines a one-to-many relationship between objects. When one object (Subject) changes state, all its dependents (Observers) are notified and updated automatically. It is commonly used in event-driven systems, notifications, and real-time applications.
In this guide, we'll break down:
The Observer Pattern defines a relationship where one object (the Subject) notifies multiple other objects (the Observers) about changes in its state. Observers register with the subject and are updated whenever the subject’s state changes.
It’s like a publish-subscribe model:
The Observer Pattern is ideal for:
Let’s implement a weather monitoring system where multiple devices (observers) display the temperature whenever it changes.
javaimport java.util.ArrayList;
import java.util.List;
// Subject Interface
interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}
// Observer Interface
interface Observer {
void update(float temperature);
}
// Concrete Subject
class WeatherStation implements Subject {
private List<Observer> observers;
private float temperature;
public WeatherStation() {
this.observers = new ArrayList<>();
}
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(temperature);
}
}
public void setTemperature(float temperature) {
this.temperature = temperature;
notifyObservers();
}
}
// Concrete Observer 1: Phone Display
class PhoneDisplay implements Observer {
private float temperature;
@Override
public void update(float temperature) {
this.temperature = temperature;
System.out.println("Phone Display: Temperature updated to " + temperature + "°C");
}
}
// Concrete Observer 2: TV Display
class TVDisplay implements Observer {
private float temperature;
@Override
public void update(float temperature) {
this.temperature = temperature;
System.out.println("TV Display: Temperature updated to " + temperature + "°C");
}
}
// Client Code
public class Client {
public static void main(String[] args) {
WeatherStation weatherStation = new WeatherStation();
// Create observers
Observer phoneDisplay = new PhoneDisplay();
Observer tvDisplay = new TVDisplay();
// Register observers
weatherStation.registerObserver(phoneDisplay);
weatherStation.registerObserver(tvDisplay);
// Simulate temperature change
weatherStation.setTemperature(25.5f);
weatherStation.setTemperature(30.0f);
}
}
plaintextPhone Display: Temperature updated to 25.5°C TV Display: Temperature updated to 25.5°C Phone Display: Temperature updated to 30.0°C TV Display: Temperature updated to 30.0°C
Here’s the UML diagram for our Weather Monitoring System:
The Observer Design Pattern is ideal for systems where multiple objects need to stay synchronized with a subject’s state. By following the principles of loose coupling and dynamic updates, this pattern makes your code modular, maintainable, and scalable.
Start implementing the Observer Pattern in your projects to handle real-time updates like a pro!