实现监听模式（Observer Pattern） in Java

监听模式（又称观察者模式）是一种常见的软件设计模式，主要用于建立对象之间的一对多依赖关系。在这种模式中，当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。这种模式在事件处理、数据绑定等场景中非常有用。下面是实现观察者模式的流程及相应的代码实现。

实现流程

步骤描述
步骤 1定义观察者接口
步骤 2创建具体观察者类，实现观察者接口
步骤 3定义被观察者接口
步骤 4创建具体被观察者类，实现被观察者接口
步骤 5在主程序中演示观察者模式的使用

详细实现步骤

步骤 1: 定义观察者接口

首先，我们需要一个观察者接口，用于定义观察者需要实现的方法。

// Observer.java
public interface Observer {
    void update(String message); // 通知方法，接受被观察者发送的信息
}
  • 1.
  • 2.
  • 3.
  • 4.
步骤 2: 创建具体观察者类

接下来，创建一个具体观察者类，实现观察者接口。

// ConcreteObserver.java
public class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name; // 记录观察者的名字
    }

    @Override
    public void update(String message) {
        System.out.println(name + " 收到了消息: " + message); // 输出收到了消息
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
步骤 3: 定义被观察者接口

然后，我们定义一个被观察者接口，用于管理观察者。

// Subject.java
import java.util.ArrayList;
import java.util.List;

public interface Subject {
    void registerObserver(Observer observer); // 添加观察者方法
    void removeObserver(Observer observer); // 移除观察者方法
    void notifyObservers(String message); // 通知观察者方法
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
步骤 4: 创建具体被观察者类

接下来，实现一个具体的被观察者类。

// ConcreteSubject.java
public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>(); // 存储观察者列表
    private String state; // 被观察者状态

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer); // 添加观察者
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer); // 移除观察者
    }

    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message); // 通知所有观察者
        }
    }

    public void changeState(String state) {
        this.state = state; // 改变状态
        notifyObservers(state); // 通知观察者状态改变
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
步骤 5: 在主程序中演示观察者模式的使用

最后，在主程序中设置观察者和被观察者的关系。

// Main.java
public class Main {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject(); // 创建被观察者

        Observer observer1 = new ConcreteObserver("观察者1"); // 创建观察者
        Observer observer2 = new ConcreteObserver("观察者2");

        subject.registerObserver(observer1); // 注册观察者
        subject.registerObserver(observer2);

        subject.changeState("新状态1"); // 改变状态
        subject.changeState("新状态2"); // 改变状态
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.

UML图示

类图
Subject +registerObserver(observer: Observer) +removeObserver(observer: Observer) +notifyObservers(message: String) Observer +update(message: String) ConcreteSubject -observers: List -state: String +changeState(state: String) ConcreteObserver -name: String +update(message: String)
序列图
Observer2 Observer1 ConcreteSubject Observer2 Observer1 ConcreteSubject notifyObservers("新状态1") notifyObservers("新状态1") notifyObservers("新状态2") notifyObservers("新状态2")

结论

通过以上步骤，我们成功实现了观察者模式，理解了其核心思想和实现方式。利用这一模式可以有效地处理对象之间的通知机制，使得程序设计更加灵活。希望通过这篇文章，你能够掌握监听模式的基本应用。在未来的开发中，可以根据需求灵活运用这一模式，以便更好地应对复杂的业务需求。