Module 1: Design Pattern: Observer and State

Learning Objectives

• Understand the Observer Pattern
  • Understand Observers
  • Understand Sources
  • Understand when and how sources interact with and update observers
• Be able to implement an observer pattern in an existing application
• Understand how the observer pattern helps make fewer costly calls to a database
• Understand real life examples of when you would want to use an observer pattern
• Understand the utility of defining and implementing an interface

About the Observer Pattern

The Observer design pattern defines a dependency among cooperating objects so that when one object's state changes, all dependent objects are notified automatically. This pattern is commonly used in event handling systems, social media notifications, and many other applications where loose coupling between components is important.

Elements of the Observer Pattern

The Observer pattern consists of four distinct elements:

• Subject - An interface or abstract class that defines methods for attaching, detaching, and notifying observers
• Observer - An interface or abstract class with an update method that gets called when the subject's state changes
• Concrete Subject - A class that implements the Subject interface and maintains a list of observers
• Concrete Observer - A class that implements the Observer interface and registers with a Concrete Subject to receive updates

Example Implementation

Here's how you might implement a simple Observer pattern in Java:

// Subject interface
public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

// Observer interface
public interface Observer {
    void update();
}

// Concrete Subject
public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;
    
    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }
    
    public String getState() {
        return state;
    }
    
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

// Concrete Observer
public class ConcreteObserver implements Observer {
    private ConcreteSubject subject;
    private String observerState;
    
    public ConcreteObserver(ConcreteSubject subject) {
        this.subject = subject;
        subject.attach(this);
    }
    
    @Override
    public void update() {
        observerState = subject.getState();
        System.out.println("Observer state updated to: " + observerState);
    }
}