正文

Java实战：轻松掌握观察者模式实现代码解析与应用案例

/0 浏览量
1018

观察者模式（Observer Pattern）是一种设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。这种模式在Java开发中非常实用，可以帮助我们实现解耦和模块化的代码。

观察者模式的核心概念

在观察者模式中，有两个核心角色：

  • 观察者（Observer）：观察者订阅了被观察者的状态变化，并在状态变化时进行相应的操作。
  • 被观察者（Subject）：被观察者持有观察者的引用列表，当状态变化时，通知所有观察者。

Java实现观察者模式

以下是一个简单的Java观察者模式实现示例：

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

// 被观察者接口
interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

// 具体被观察者类
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private int state;

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

    public void detach(Observer observer) {
        observers.remove(observer);
    }

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

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }

    public int getState() {
        return state;
    }
}

// 观察者接口
interface Observer {
    void update(Subject subject);
}

// 具体观察者类
class ConcreteObserver implements Observer {
    private int observerState;

    @Override
    public void update(Subject subject) {
        observerState = ((ConcreteSubject) subject).getState();
        System.out.println("Observer state changed to: " + observerState);
    }
}

应用案例

以下是一个使用观察者模式的简单应用案例，模拟股票价格的实时更新：

被观察者：StockPriceSubject

class StockPriceSubject extends ConcreteSubject {
    private double price;

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

    @Override
    public void update(Observer observer) {
        observer.update(this);
    }

    public double getPrice() {
        return price;
    }
}

观察者：StockPriceObserver

class StockPriceObserver implements Observer {
    private double lastPrice = -1;

    @Override
    public void update(Subject subject) {
        double price = ((StockPriceSubject) subject).getPrice();
        if (lastPrice != price) {
            System.out.println("Stock price changed to: " + price);
            lastPrice = price;
        }
    }
}

测试

public class ObserverPatternTest {
    public static void main(String[] args) {
        StockPriceSubject subject = new StockPriceSubject();
        StockPriceObserver observer = new StockPriceObserver();

        subject.attach(observer);
        subject.setPrice(100);
        subject.setPrice(150);
        subject.setPrice(200);
        subject.setPrice(250);

        subject.detach(observer);
        subject.setPrice(300);
    }
}

在上述测试中，观察者会接收到股票价格的变化通知，并打印出价格变化。

总结

通过以上代码示例，我们可以看到观察者模式在Java中的实现方法。在实际开发中，观察者模式可以帮助我们实现解耦和模块化，提高代码的可维护性和可扩展性。掌握观察者模式，能够让你在Java开发中游刃有余。

-- 展开阅读全文 --