Skip to main content

Command Palette

Search for a command to run...

Observer Design Pattern

Updated
2 min read
Observer Design Pattern

Define a one-to-many dependency so that when one object changes state, all its dependents are notified and updated automatically. The main intention of this design pattern is that the subject maintains a list of observers. When the subject's state changes, it calls notifyAll(), which in turn calls update() on every registered Observer. Observers register and deregister dynamically at runtime.

interface Observer {
    void update(String videoTitle);
}
class Subscriber implements Observer {
    private String name;
    public Subscriber(String name) {
        this.name = name;
    }
    @override 
    public void update(String videoTitle) {
        System.out.println(name + "received notification: New video uploaded - " + videoTitle);
    }
}
interface Subject {
    void subscribe(Observer observer);
    void unsubscribe(Observer observer);
    void notifySubscribers();
}
class YouTubeChannel implements Subject {
    private List<Observer> subscribers = new ArrayList<>();
    private String latestVideo;
    
    @override 
    public void subscribe(Observer observer) {
        subscribers.add(observer);
    }

    @override 
    public void unsubscribe(Observer observer) {
        subscribers.remove(observer);
    }
    
    @override 
    public void notifySubscribers() {
        for(Observer observer : subscribers) {
            observer.update(lastestVideo);
        }
    }
    
    public void uploadVideo(String videoTitle) {
        this.latestVideo = videoTitle;
        System.out.println("Channel uploaded: " + videoTitle);
        notifySubscribers();
    }
}
public class ObserverPatternDemo {
    public static void main(String[] args) {
        YouTubeChannel channel = new YouTubeChannel();
        Observer alice = new Subscriber("Alice");
        Observer bob = new Subscriber("Bob");
        Observer charlie = new Subscriber("Charlie");
        channel.subscribe(alice);
        channel.subscribe(bob);
        channel.subscribe(charlie);
        channel.uploadVideo("Observer Pattern Explained");
        System.out.println();
        channel.unsubscribe(bob);
        channel.uploadVideo("Strategy pattern Explained");
    }
}

When to use:

  • You're building event-driven systems.

  • You need publish-subscriber style communication.

  • Easy to add new observers without changing existing code.