What is the Observer Pattern in Java?

Can you explain the Observer Pattern in Java?

Sure! 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 do I implement it in my Java application?

To implement the Observer Pattern, you need to create a Subject class that maintains a list of observers and methods to attach, detach, and notify them. Then, create Observer classes that implement an update method.

Can you provide a code example?

Absolutely! 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 detach(Observer observer) {
        observers.remove(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 to create a subject and observers.

What are some use cases for the Observer Pattern?

The Observer Pattern is commonly used in event handling systems, such as GUI frameworks, where multiple components need to respond to events. It's also used in implementing publish-subscribe systems.