What is the Observer Pattern in Java?

Can you explain what the Observer Pattern is in Java?

The Observer Pattern is a behavioral design pattern that allows an object, known as the subject, to maintain a list of its dependents, called observers, and notify them of any state changes.

How does it work in practice?

In practice, the subject maintains a list of observers and provides methods to attach and detach them. When the subject's state changes, it calls a method on each observer to notify them.

Can you give me a code example?

Sure! Here's a simple example:

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

interface Observer {
    void update(String message);
}

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

    public void attach(Observer observer) {
        observers.add(observer);
    }

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

class ConcreteObserver implements Observer {
    private String name;

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

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

public class Main {
    public static void main(String[] args) {
        Subject subject = new Subject();
        ConcreteObserver observer1 = new ConcreteObserver("Observer 1");
        ConcreteObserver observer2 = new ConcreteObserver("Observer 2");

        subject.attach(observer1);
        subject.attach(observer2);

        subject.notifyObservers("Hello Observers!");
    }
}

This code demonstrates how observers are notified when the subject's state changes.

What are the benefits of using the Observer Pattern?

The benefits include loose coupling between the subject and observers, easier maintenance, and the ability to add new observers without modifying the subject.