Java Design Patterns Observer Pattern Deep Dive

The Observer pattern is a design pattern that allows objects to subscribe to event notifications and automatically respond when events occur. In Java, it is usually implemented using the Observable (Subject) and Observer (Observer) interfaces, where the subject maintains a collection of observers and notifies them when changes occur. The Observer pattern provides the advantages of loose coupling, scalability, and efficient notifications and is widely used in the following scenarios: event-driven programming, GUI updates, and Pub/Sub systems.

In-depth analysis of the observer pattern of Java design patterns

Introduction

The observer pattern is a design Pattern that allows objects to subscribe to event notifications to automatically respond when an event occurs. In this way, observers can receive updates from topics or publishers without explicitly polling.

Implementation method

The observer pattern in Java usually uses the following interface:

• Observable (topic) : Defines methods for observer registration, unregistration and notification.
• Observer (Observer): Defines the update method, which will be called when the observed object changes.

In practical applications, subjects usually implement the Observable interface, while observers implement the Observer interface. The topic maintains a collection of observers and notifies them by calling the observer's update method.

Practical Case

Suppose we have a stock market application that needs to monitor stock prices in real time. We can use the observer pattern to achieve this functionality.

Topic: Stocks

public class Stock implements Observable {

    private List<Observer> observers;
    private double price;

    public Stock() {
        observers = new ArrayList<>();
    }

    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void deleteObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(this);
        }
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
        notifyObservers();
    }
}

Observer: Stock Price Display

public class StockPriceDisplay implements Observer {

    private Stock stock;

    public StockPriceDisplay(Stock stock) {
        this.stock = stock;
        stock.addObserver(this);
    }

    @Override
    public void update(Observable observable) {
        double price = stock.getPrice();
        System.out.println("Current stock price: " + price);
    }
}

Example Usage

In the example usage, we create a stock object and register an observer to monitor its price:

Stock stock = new Stock();
StockPriceDisplay display = new StockPriceDisplay(stock);

// 设置股票价格，这将自动触发观察者更新
stock.setPrice(100.0);

Advantages

The observer pattern provides Some advantages:

• Loose coupling: Communication between observers and topics is loosely coupled, allowing modifications without affecting each other.
• Extensibility: It is easy to add and remove observers without modifying the theme's implementation.
• Notification efficiency: When a topic changes, the observer pattern efficiently propagates updates to all subscribers.

Application scenarios

The observer mode is widely used in various scenarios, such as:

• Monitoring system
• Event Driven Programming
• GUI Update
• Pub/Sub System

The above is the detailed content of Java Design Patterns Observer Pattern Deep Dive. For more information, please follow other related articles on the PHP Chinese website!