11.5.1. Observer Pattern

Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified.

The Observer Pattern is a behavioral design pattern used to manage how objects interact with each other. In this pattern, there is one subject (the object being observed) and one or more observers (the objects that watch the subject). When the subject's state changes, it notifies all registered observers of this change. This promotes decoupling between the subject and its observers, allowing flexibility in how different parts of a system can interact without tightly binding them together.

Imagine a weather station that measures temperature. The weather station is the subject, and different displays (like a digital thermometer, a mobile app, or a web dashboard) are the observers. Whenever the temperature changes, the weather station notifies all its observers, allowing them to update their displays with the latest temperature without the station having to know the specifics of how each display operates.

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

The Observer interface is a contract that all concrete observer classes must implement. It defines a method, usually called update, which takes a message as a parameter. This method gets called by the subject whenever a change occurs. Implementing this interface allows different observer classes to respond differently to updates, making the system flexible and modular.

Think of the Observer interface like a subscription service. If someone subscribes to a magazine, they expect to receive updates (the magazine issues) regularly. Each magazine edition contains different articles or topics, and subscribers (observers) can decide how to react to them or what to focus on.

class ConcreteObserver implements Observer {
public void update(String message) {
System.out.println("Message received: " + message);
}```

The ConcreteObserver class implements the Observer interface. It provides the behavior that occurs when the update method is called, in this case, printing a message to the console. This means that every time an update is notified from the subject, this implementation will react by executing the code within the update method. Different observers can implement the update method in various ways to meet their specific needs.

Continuing with the magazine analogy, the ConcreteObserver might represent a specific subscriber who decides to always share news with their friends, thus printing any updates they receive. So every time they receive a magazine, they tell their friends what the latest articles are about.

class Subject {
private List<Observer> observers = new ArrayList<>();
public void addObserver(Observer o) { observers.add(o); }
public void notifyObservers(String message) {
for (Observer o : observers) {
o.update(message);
}
}
}```

The Subject class holds a list of observers and provides methods for adding observers (addObserver) and notifying them of updates (notifyObservers). When notifyObservers is called, it goes through the list of observers and calls their update method, passing along the message. This centralizes the management of observers and allows the subject to notify multiple observers effortlessly.

Think of the Subject as the weather station again. This station keeps track of who wants to know the temperature (the observers). When the temperature changes, it just has to tell all its subscribers (observers) at once rather than checking in with each one individually. This makes the process efficient.

--