Observer Design Pattern

What is the Observer Design Pattern?

The Observer Design Pattern is a behavioral design pattern. It is used when one object needs to inform other objects automatically whenever its state changes.

In simple words, it works like a subscription system. One object acts as a subject, and many other objects act as observers. When the subject changes, all registered observers are notified.

Real-Life Example

Think about a YouTube channel:

• The YouTube channel is the Subject.
• Subscribers are the Observers.
• When a new video is uploaded, all subscribers get notified automatically.

This is exactly how the Observer Pattern works.

Key Components of Observer Pattern

• Subject – Maintains a list of observers and notifies them of changes.
• Observer – Defines a method to receive updates.
• ConcreteSubject – Implements the subject and stores state.
• ConcreteObserver – Implements the observer and reacts to updates.

When Should You Use Observer Pattern?

• When multiple objects depend on one object’s state
• When you want loose coupling between objects
• When changes in one object should update others automatically

Observer Design Pattern – Java Example

Step 1: Create Observer Interface

public interface Observer {
    void update(String message);
}

Step 2: Create Subject Interface

import java.util.List;

public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

Step 3: Create Concrete Subject

import java.util.ArrayList;
import java.util.List;

public class NewsChannel implements Subject {

    private List<Observer> observers = new ArrayList<>();
    private String news;

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void setNews(String news) {
        this.news = news;
        notifyObservers();
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(news);
        }
    }
}

Step 4: Create Concrete Observers

public class NewsSubscriber implements Observer {

    private String name;

    public NewsSubscriber(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received news: " + message);
    }
}

Step 5: Test the Observer Pattern

public class ObserverPatternDemo {

    public static void main(String[] args) {

        NewsChannel channel = new NewsChannel();

        Observer user1 = new NewsSubscriber("Amit");
        Observer user2 = new NewsSubscriber("Sandeep");

        channel.registerObserver(user1);
        channel.registerObserver(user2);

        channel.setNews("Observer Pattern Explained Simply!");
    }
}

Output

Amit received news: Observer Pattern Explained Simply!
Sandeep received news: Observer Pattern Explained Simply!

Advantages of Observer Pattern

• Promotes loose coupling between objects
• Easy to add or remove observers
• Supports open-closed principle

Disadvantages of Observer Pattern

• Too many observers can affect performance
• Notification order is not guaranteed

Conclusion

The Observer Design Pattern is a powerful way to handle one-to-many relationships. It is commonly used in event handling systems, notification services, and real-time updates. By using this pattern, your code becomes flexible, clean, and easy to maintain.