👀 Observer Design Pattern in Java

The Observer Pattern is a behavioral design pattern where one object (subject) notifies a group of dependent objects (observers) whenever its state changes.

It’s widely used in:

• UI event handling (e.g., button clicks)
• Notification systems
• Real-time updates (chat, stock prices, etc.)

🎯 Real-Life Analogy

📱 Imagine a YouTube channel:

• You're the Subscriber (Observer)
• The Channel is the Subject

Whenever a new video is uploaded, you get notified. That's the Observer pattern in action!

🔧 When to Use Observer Pattern?

• When multiple objects need to stay updated with changes in one object.
• When you're building event-driven systems.
• When you want to decouple subjects and their dependents.

🔥 Example – Notification System

Let’s build a system where users get notified when a new message is published.

🔸 Step 1: Create Observer Interface

interface Observer {
    void update(String message);
}

🔸 Step 2: Concrete Observers (Subscribers)

class EmailSubscriber implements Observer {
    private String email;

    public EmailSubscriber(String email) {
        this.email = email;
    }

    public void update(String message) {
        System.out.println("Email to " + email + ": " + message);
    }
}

class SMSSubscriber implements Observer {
    private String phoneNumber;

    public SMSSubscriber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    public void update(String message) {
        System.out.println("SMS to " + phoneNumber + ": " + message);
    }
}

🔸 Step 3: Create Subject Interface

interface Subject {
    void subscribe(Observer o);
    void unsubscribe(Observer o);
    void notifyObservers(String message);
}

🔸 Step 4: Concrete Subject (Publisher)

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

class MessagePublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();

    public void subscribe(Observer o) {
        observers.add(o);
    }

    public void unsubscribe(Observer o) {
        observers.remove(o);
    }

    public void notifyObservers(String message) {
        for (Observer o : observers) {
            o.update(message);
        }
    }
}

🔸 Step 5: Test the System

public class ObserverDemo {
    public static void main(String[] args) {
        MessagePublisher publisher = new MessagePublisher();

        Observer emailUser = new EmailSubscriber("ayan@xyz.com");
        Observer smsUser = new SMSSubscriber("9876543210");

        publisher.subscribe(emailUser);
        publisher.subscribe(smsUser);

        publisher.notifyObservers("📢 New Blog Post on Observer Pattern!");

        publisher.unsubscribe(emailUser);

        publisher.notifyObservers("📢 New Update: SOLID Principles Refreshed!");
    }
}

✅ Output

📌 Key Concepts

| Concept | Description | | -------------- | -------------------------------------- | | Subject | Maintains list of observers | | Observer | Gets notified of changes | | Loose Coupling | Subject doesn’t care what observers do | | Flexibility | Can add/remove observers at runtime |

🔁 Real-Time Use Cases

• ✅ UI components (React/Angular bindings)
• ✅ Event buses or messaging systems
• ✅ Chat applications
• ✅ Stock ticker updates
• ✅ File system change monitors

🧠 Interview Q&A

Q: What type of pattern is Observer? A: Behavioral

Q: What's the difference between Observer and Publisher-Subscriber? A:

• Observer is tightly coupled, usually direct references.
• Pub/Sub uses a message broker (like Kafka, RabbitMQ).

Q: Is Observer pattern used in Java libraries? A: Yes! For example:

• java.util.Observer (deprecated, but historically used)
• Event listeners in Swing/AWT (UI frameworks)

🧠 Observer vs Strategy vs Decorator

| Pattern | Purpose | | --------- | -------------------------------- | | Observer | Notify many on state change | | Strategy | Choose behavior at runtime | | Decorator | Add responsibilities dynamically |

📚 Summary

• ✅ Observer helps you notify multiple objects when state changes.
• 🔗 Promotes loose coupling between subject and observers.
• 🔄 Easy to extend, reuse, and manage listeners.
• 🧩 Perfect for real-time, event-driven systems.