观察者模式,Java实现
时间: 2023-05-14 16:07:27 浏览: 90
观察者模式是一种软件设计模式,它定义了对象之间的一对多依赖关系,使得当一个对象状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。在 Java 中,可以使用 java.util.Observable 和 java.util.Observer 来实现观察者模式。具体的实现方法是,被观察者继承 Observable 类,观察者实现 Observer 接口,然后使用 addObserver() 方法将观察者添加到被观察者中,最后在被观察者中调用 setChanged() 和 notifyObservers() 方法来通知观察者状态的更改。
相关问题
java 观察者模式接口实现
观察者模式是一种设计模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象,当主题对象发生变化时,它的所有观察者都会收到通知并自动更新。在 Java 中,观察者模式可以通过接口实现,以下是一个简单的实现示例:
```java
// 主题接口
interface Subject {
void registerObserver(Observer observer); // 注册观察者
void removeObserver(Observer observer); // 移除观察者
void notifyObservers(); // 通知所有观察者
}
// 观察者接口
interface Observer {
void update(); // 更新方法
}
// 具体主题类
class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update();
}
}
}
// 具体观察者类
class ConcreteObserver implements Observer {
private Subject subject;
public ConcreteObserver(Subject subject) {
this.subject = subject;
subject.registerObserver(this);
}
@Override
public void update() {
// 处理更新通知
}
}
```
在这个示例中,`Subject` 接口定义了注册、移除和通知观察者的方法,`Observer` 接口定义了更新方法,具体的主题和观察者类实现了这些接口。通过使用这些接口,我们可以实现简单的观察者模式。
使用java实现观察者模式
观察者模式是一种常见的设计模式,它的主要思想是在对象之间建立一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。
在Java中,观察者模式的实现需要定义两个角色:Subject(主题)和Observer(观察者)。Subject负责维护一组观察者对象,以及通知它们状态的变化;而Observer则负责接收Subject的通知,并做出相应的处理。
下面是一个简单的Java实现:
```java
import java.util.ArrayList;
import java.util.List;
// 主题接口
interface Subject {
void attach(Observer observer); // 添加观察者
void detach(Observer observer); // 移除观察者
void notifyObservers(); // 通知所有观察者
}
// 观察者接口
interface Observer {
void update(); // 更新状态
}
// 具体主题类
class ConcreteSubject implements 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() {
for (Observer observer : observers) {
observer.update();
}
}
// 主题状态的变化
public void changeState() {
// do something
notifyObservers(); // 通知所有观察者
}
}
// 具体观察者类
class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
public void update() {
System.out.println(name + " has received the update.");
}
}
// 测试
public class ObserverPatternDemo {
public static void main(String[] args) {
Subject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver("Observer1");
Observer observer2 = new ConcreteObserver("Observer2");
Observer observer3 = new ConcreteObserver("Observer3");
subject.attach(observer1);
subject.attach(observer2);
subject.attach(observer3);
((ConcreteSubject) subject).changeState();
subject.detach(observer2);
((ConcreteSubject) subject).changeState();
}
}
```
在这个例子中,我们定义了Subject和Observer两个接口,以及它们的具体实现类ConcreteSubject和ConcreteObserver。其中ConcreteSubject负责维护一组观察者对象,并在状态变化时通知它们;而ConcreteObserver则负责接收Subject的通知,并做出相应的处理。
在测试代码中,我们创建了一个ConcreteSubject对象,并向它添加了三个ConcreteObserver观察者。然后我们调用changeState()方法改变主题的状态,这会触发ConcreteSubject通知所有观察者。最后我们移除了一个观察者,并再次调用changeState()方法,这时只有两个观察者会收到通知。