深入解析Java设计模式编程中观察者模式的运用
观察者模式是一种经典的设计模式,它能够实现对象之间的一对多依赖关系。当一个对象状态发生改变时,其所有关联对象都能够收到通知并自动更新。
观察者模式的定义
观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时,所有的观察者对象都能够收到通知并自动更新。
观察者模式主要包含以下角色:
- Subject(主题):它必须能够动态地增加、删除观察者对象;而且当主题状态发生变化时,所有的观察者对象都能够收到通知。
- ConcreteSubject(具体主题):将有关状态存入到具体观察者对象;在具体主题的内部状态改变时,给所有登记过的观察者发送通知。
- Observer(观察者):为所有的具体观察者定义一个更新接口,在得到主题通知时更新自己。
- ConcreteObserver(具体观察者):实现在接收到通知时进行自身状态更新的方法。
观察者模式的应用场景
- 一个对象的改变会引起其他多个对象的改变,而且这些对象之间存在一种关系可以用被观察者和观察者来描述。
- 当一个抽象模型有两个方面,其中一个方面依赖于另一个方面,将这两个方面用观察者模式分离出来,可以分别实现解耦,从而提高系统的灵活性和可维护性。
观察者模式的实现示例
1. 利用观察者模式实现监听器
首先定义主题接口Subject和观察者接口Observer:
public interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers(Object obj);
}
public interface Observer {
void update(Object obj);
}
然后我们创建一个具体的主题实现类ConcreteSubject,实现Subject接口的相关方法:registerObserver、removeObserver、notifyObservers。
public 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(Object obj) {
for (Observer observer : observers) {
observer.update(obj);
}
}
}
最后我们再创建一个具体观察者实现类ConcreteObserver,实现Observer接口的相关方法:update。
public class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(Object obj) {
System.out.println(name + "收到了事件通知,事件内容为:" + obj);
}
}
下面我们来看一个示例,利用观察者模式实现监听器:
public static void main(String[] args) {
Subject subject = new ConcreteSubject();
subject.registerObserver(new ConcreteObserver("观察者1"));
subject.registerObserver(new ConcreteObserver("观察者2"));
subject.notifyObservers("事件1发生了");
subject.notifyObservers("事件2发生了");
subject.removeObserver(new ConcreteObserver("观察者1"));
subject.notifyObservers("事件3发生了");
}
输出结果:
观察者1收到了事件通知,事件内容为:事件1发生了
观察者2收到了事件通知,事件内容为:事件1发生了
观察者1收到了事件通知,事件内容为:事件2发生了
观察者2收到了事件通知,事件内容为:事件2发生了
观察者2收到了事件通知,事件内容为:事件3发生了
2. 利用观察者模式实现一比分实时更新的应用
首先定义主题接口Subject和观察者接口Observer:
public interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}
public interface Observer {
void update(int homeScore, int guestScore);
}
然后我们创建一个具体的主题实现类ConcreteSubject,实现Subject接口的相关方法:registerObserver、removeObserver、notifyObservers。
public class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
private int homeScore;
private int guestScore;
@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(homeScore, guestScore);
}
}
public void setScore(int homeScore, int guestScore) {
this.homeScore = homeScore;
this.guestScore = guestScore;
notifyObservers();
}
}
最后我们再创建一个具体观察者实现类ConcreteObserver,实现Observer接口的相关方法:update。
public class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(int homeScore, int guestScore) {
System.out.println(name + ":主队" + homeScore + " - 客队" + guestScore);
}
}
下面我们来看一个示例,利用观察者模式实现一比分实时更新的应用:
public static void main(String[] args) throws InterruptedException {
Subject subject = new ConcreteSubject();
subject.registerObserver(new ConcreteObserver("用户1"));
subject.registerObserver(new ConcreteObserver("用户2"));
for (int i = 0; i < 3; i++) {
System.out.println("比分更新");
((ConcreteSubject) subject).setScore(new Random().nextInt(5), new Random().nextInt(5));
Thread.sleep(1000);
}
}
输出结果:
比分更新
用户1:主队3 - 客队1
用户2:主队3 - 客队1
比分更新
用户1:主队1 - 客队1
用户2:主队1 - 客队1
比分更新
用户1:主队2 - 客队3
用户2:主队2 - 客队3
本站文章如无特殊说明,均为本站原创,如若转载,请注明出处:深入解析Java设计模式编程中观察者模式的运用 - Python技术站