首页 > 代码库 > 大话设计模式_观察者模式(Java代码)

大话设计模式_观察者模式(Java代码)

2024-07-07 12:25:54   224人阅读

观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们自己能够自动更新自己。
简单描述：1个Subject类(可以是抽象类可以是接口)，可以有多个具体Subject类(继承抽象Subject)，此具体Subject持有多个观察者的引用，在此具体Subject状态发生变化的时候调用这些观察者的相应方法。另外，这些持有的引用是抽象的，不是具体的，而这些引用所指向的对象时具体的观察者(即需要作出更新的具体观察者，这些具体观察者可以持有具体Subject的引用，以便了解具体Subject的状态)
大话设计模式中的截图：

代码例子：

AbstractSubject类：

 1 package com.longsheng.observer;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public abstract class AbstractSubject {
 7 
 8     private String subjectState;
 9     private List<AbstractObserver> mList = new ArrayList<AbstractObserver>();
10 
11     public String getSubjectState() {
12         return subjectState;
13     }
14 
15     public void setSubjectState(String subjectState) {
16         this.subjectState = subjectState;
17     }
18 
19     public void addObserver(AbstractObserver mAbstractObserver) {
20         mList.add(mAbstractObserver);
21     }
22 
23     public void removeObserver(AbstractObserver mAbstractObserver) {
24         mList.remove(mAbstractObserver);
25     }
26 
27     public void notifyObservers() {
28         for (AbstractObserver mAbstractObserver : mList) {
29             mAbstractObserver.update();
30         }
31     }
32 }

Secretary类(ConcreteSubject):

1 package com.longsheng.observer;
2 
3 public class Secretary extends AbstractSubject {
4 //此类中的方法已在抽象类中实现，所以暂不需要添加新方法
5 }

AbstractObserver类：

 1 package com.longsheng.observer;
 2 
 3 public abstract class AbstractObserver {
 4 
 5     protected String observerName;
 6     protected AbstractSubject mAbstractSubject;
 7 
 8     public AbstractObserver(String name, AbstractSubject mSubject) {
 9         observerName = name;
10         mAbstractSubject = mSubject;
11     }
12 
13     public abstract void update();
14 
15 }

StockObserver类(ConcreteObserver)：

 1 package com.longsheng.observer;
 2 
 3 public class StockObserver extends AbstractObserver {
 4 
 5     public StockObserver(String name, AbstractSubject mSubject) {
 6         super(name, mSubject);
 7     }
 8 
 9     @Override
10     public void update() {
11         System.out.println(mAbstractSubject.getSubjectState() + " , "
12                 + this.observerName + "关闭股票界面，继续工作");
13     }
14 
15 }

NBAObserver类(ConcreteObserver)：

 1 package com.longsheng.observer;
 2 
 3 public class NBAObserver extends AbstractObserver {
 4 
 5     public NBAObserver(String name, AbstractSubject mSubject) {
 6         super(name, mSubject);
 7     }
 8 
 9     @Override
10     public void update() {
11         System.out.println(mAbstractSubject.getSubjectState() + " , "
12                 + this.observerName + "关闭NBA直播，继续工作");
13     }
14 
15 }

客户端：

 1 package com.longsheng.observer;
 2 
 3 public class Client {
 4 
 5     public static void main(String[] args) {
 6         Secretary mSecretary = new Secretary();
 7         StockObserver mStockObserver = new StockObserver("小红", mSecretary);
 8         NBAObserver mNBAObserver = new NBAObserver("小黄", mSecretary);
 9         
10         mSecretary.addObserver(mStockObserver);
11         mSecretary.addObserver(mNBAObserver);
12         
13         mSecretary.setSubjectState("经理回来啦");
14         mSecretary.notifyObservers();
15     }
16 
17 }

运行结果：

1 经理回来啦 , 小红关闭股票界面，继续工作
2 经理回来啦 , 小黄关闭NBA直播，继续工作

将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维护一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便。

使用场景：当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象需要改变时，应该考虑使用观察者模式。

一个抽象模型有两个方面，其中一方面依赖于另外一方面，这时候观察者模式可以将这两者封装在独立的对象中使它们各自独立的改变和复用


联系
我们