【设计模式】把风放哨，防老板 --- 观察者模式

最新推荐文章于 2024-09-20 16:52:43 发布
最新推荐文章于 2024-09-20 16:52:43 发布
阅读量1.1k 收藏
点赞数 2
分类专栏： 【设计模式】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianshuai1111/article/details/7703977
版权

一，概述

        观察者<Observer>模式（有时又被称为发布-订阅<Publish/Subscribe>模式、模型-视图<Model/View>模式、源-收听者<Source/Listener>模式或从属者<Dependents>模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。

 

二，示例

        题目描述：公司里有的员工偷懒，看股票，看NBA。老板回来需要有人通知他们，然后再好好干活。通知大家的任务交给前台。

 

       1）双向耦合的代码 （读此代码之前先看两个类互相包含）       

             缺点：前台通知类和看股票者相互耦合。如果再想增加一个看NBA的类就违反“开放-- 封闭原则”

  

             StockObserver.h类（）

#include <iostream>
#include <string>

using namespace std;

class Secretary;

//看股票的同事
 class StockObserver
 {
        private:
		 string name;
         Secretary *sub;

        public:
		 StockObserver(string name, Secretary *sub)
        {
            this->name = name;//这里一定要加上this
            this->sub = sub;
        }

        void Update()
        {
			
            //cout<<sub->getAction()<<name<<"关闭股票行情，继续工作！"<<endl;

			cout<<name<<"!!关闭股票行情，继续工作！"<<endl;
        }
    };


 

          Secretary.h

#include <iostream>
#include <list>
#include <algorithm>
#include "StockObserver.h"
using namespace std;


template<typename T>
struct display
{
	void operator()( T &observer)
	{
		observer.Update();
	}
	
	
};

class Secretary
{
        //同事列表
        private:
		 list<StockObserver> observers;// = new List<StockObserver>();
         string action;

        public:
        //增加
			friend class StockObserver;
        void Attach(StockObserver observer)
        {
            observers.push_back(observer);
        }

        //减少
        void Detach(StockObserver observer)
        {
            observers.pop_back();
        }

        //通知
        void Notify()
        {
                
            for_each(observers.begin(),observers.end(),display<StockObserver>());
               
        }

        //前台状态
       void  SecretaryAction(string value)
        {
             action = value;
             
        }


    };



           main.cpp（客户端程序）

#include <iostream>
#include "Secretary.h"

using namespace std;

int main()
{

	     //前台小姐童子喆
            Secretary *tongzizhe= new Secretary();
            //看股票的同事
            StockObserver tongshi1("魏关姹", tongzizhe);
            StockObserver tongshi2 ("易管查", tongzizhe);



            //前台记下了两位同事
            tongzizhe->Attach(tongshi1);
            tongzizhe->Attach(tongshi2);
            //发现老板回来
            tongzizhe->SecretaryAction( "老板回来了！");
            //通知两个同事
            tongzizhe->Notify();

	    getchar();//防止退出的
	    return 0;
}


            2）解除耦合实践一：(C#)

 

        增加了抽象的观察者，方便扩展各种类型的扩展者。

using System;
using System.Collections.Generic;
using System.Text;

namespace 观察者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            //前台小姐童子喆
            Secretary tongzizhe = new Secretary();
            //看股票的同事
            StockObserver tongshi1 = new StockObserver("魏关姹", tongzizhe);
            //看NBA的同事
            NBAObserver tongshi2 = new NBAObserver("易管查", tongzizhe);

            //前台记下了两位同事
            tongzizhe.Attach(tongshi1);
            tongzizhe.Attach(tongshi2);
            //发现老板回来
            tongzizhe.SecretaryAction = "老板回来了！";
            //通知两个同事
            tongzizhe.Notify();


            Console.Read();
        }
    }

    //前台秘书类
    class Secretary
    {
        //同事列表
        private IList<Observer> observers = new List<Observer>();
        private string action;

        //增加
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }

        //减少
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }

        //通知
        public void Notify()
        {
            foreach (Observer o in observers)
                o.Update();
        }

        //前台状态
        public string SecretaryAction
        {
            get { return action; }
            set { action = value; }
        }

    }

    //抽象观察者
    abstract class Observer
    {
        protected string name;
        protected Secretary sub;

        public Observer(string name, Secretary sub)
        {
            this.name = name;
            this.sub = sub;
        }

        public abstract void Update();
    }


    //看股票的同事
    class StockObserver : Observer
    {
        public StockObserver(string name, Secretary sub)
            : base(name, sub)
        {
        }

        public override void Update()
        {
            Console.WriteLine("{0} {1} 关闭股票行情，继续工作！", sub.SecretaryAction, name);
        }
    }

    //看NBA的同事
    class NBAObserver : Observer
    {
        public NBAObserver(string name, Secretary sub)
            : base(name, sub)
        {
        }

        public override void Update()
        {
            Console.WriteLine("{0} {1} 关闭NBA直播，继续工作！", sub.SecretaryAction, name);
        }
    }
}


                  3）解除耦合实践二：(C#)

                                    改进：由于老板来了会自己通知职员，前台也可以偷偷通知职员老板来了。所以增加一个通知者接口。


 

using System;
using System.Collections.Generic;
using System.Text;

namespace 观察者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            //老板胡汉三
            Boss huhansan = new Boss();

            //看股票的同事
            StockObserver tongshi1 = new StockObserver("魏关姹", huhansan);
            //看NBA的同事
            NBAObserver tongshi2 = new NBAObserver("易管查", huhansan);

            huhansan.Attach(tongshi1);
            huhansan.Attach(tongshi2);

            huhansan.Detach(tongshi1);

            //老板回来
            huhansan.SubjectState = "我胡汉三回来了！";
            //发出通知
            huhansan.Notify();

            Console.Read();
        }
    }

    //通知者接口
    interface Subject
    {
        void Attach(Observer observer);
        void Detach(Observer observer);
        void Notify();
        string SubjectState
        {
            get;
            set;
        }
    }

    class Secretary : Subject
    {
        //同事列表
        private IList<Observer> observers = new List<Observer>();
        private string action;

        //增加
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }

        //减少
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }

        //通知
        public void Notify()
        {
            foreach (Observer o in observers)
                o.Update();
        }

        //前台状态
        public string SubjectState
        {
            get { return action; }
            set { action = value; }
        }
    }

    class Boss : Subject
    {
        //同事列表
        private IList<Observer> observers = new List<Observer>();
        private string action;

        //增加
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }

        //减少
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }

        //通知
        public void Notify()
        {
            foreach (Observer o in observers)
                o.Update();
        }

        //老板状态
        public string SubjectState
        {
            get { return action; }
            set { action = value; }
        }
    }

    //抽象观察者
    abstract class Observer
    {
        protected string name;
        protected Subject sub;

        public Observer(string name, Subject sub)
        {
            this.name = name;
            this.sub = sub;
        }

        public abstract void Update();
    }

    //看股票的同事
    class StockObserver : Observer
    {
        public StockObserver(string name, Subject sub)
            : base(name, sub)
        {
        }

        public override void Update()
        {
            Console.WriteLine("{0} {1} 关闭股票行情，继续工作！", sub.SubjectState, name);
        }
    }

    //看NBA的同事
    class NBAObserver : Observer
    {
        public NBAObserver(string name, Subject sub)
            : base(name, sub)
        {
        }

        public override void Update()
        {
            Console.WriteLine("{0} {1} 关闭NBA直播，继续工作！", sub.SubjectState, name);
        }
    }
}

 

三，观察者模式

 

         发布--订阅模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

        

观察者基本代码：抽象通知者类，具体实现通知者类，抽象观察者类，具体实现观察者类

                             抽象通知者为具体实现者父类，负责通知注册的观察者类

              

    class Program
    {
        static void Main(string[] args)
        {
            ConcreteSubject s = new ConcreteSubject();

            s.Attach(new ConcreteObserver(s, "X"));
            s.Attach(new ConcreteObserver(s, "Y"));
            s.Attach(new ConcreteObserver(s, "Z"));

            s.SubjectState = "ABC";
            s.Notify();

            Console.Read();

        }
    }


    abstract class Subject             //抽象通知者
    {
        private IList<Observer> observers = new List<Observer>();

        //增加观察者
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }
        //移除观察者
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }
        //通知
        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
            }
        }
    }

    //具体通知者
    class ConcreteSubject : Subject
    {
        private string subjectState;

        //具体通知者状态
        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
    }


    abstract class Observer   //抽象观察者
    {
        public abstract void Update();
    }

    class ConcreteObserver : Observer  //具体观察者
    {
        private string name;
        private string observerState;
        private ConcreteSubject subject;

        public ConcreteObserver(
          ConcreteSubject subject, string name)
        {
            this.subject = subject;
            this.name = name;
        }
        //更新
        public override void Update()
        {
            observerState = subject.SubjectState;
            Console.WriteLine("观察者{0}的新状态是{1}",
              name, observerState);
        }

        public ConcreteSubject Subject
        {
            get { return subject; }
            set { subject = value; }
        }
    }


四，观察者模式的特点

         问题：

        1）将一个系统分割成一系列相互协作的类有一个不好的副作用：需要维护相对对象的一致性

        2）我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便

        观察者优点：

         1）让耦合的双方都依赖于抽象，而不是依赖于具体。抽象不变，具体会变化

 



小田
关注
专栏目录
《大话设计模式》java实现之观察者模式
linlinxie的博客
11-15 288
观察者模式看了比较久，书中感觉说得有点乱，UML图与网上差别也比较大，先说UML，书中的UML为 从UML就可以看出，具体的Subject类（Secretary、Boss）什么都没有，连构造方法都不需要，这个也可以从代码中可以看到，完全可以放在父类Subject中实现，因此没必要再写多这几个类，参考菜鸟教程http://www.runoob.com/design-pattern/observe
【设计模式】-09观察者模式
老汉健身的博客
12-21 573
1.什么是观察者模式?   定义:在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新. 举个栗子: 张三和李四准备上演一场抢劫银行的行动,张三负责抢劫,李四负责放哨,他们两约定,如果李四这边看到警察来就立即通知张三,张三收到通知后立马逃跑...在上面的例子中,张三的角色其实就是观察者,李四是被观察者.张三观察李四这边的状态,如果李四这边的状态发生改变...
放哨——观察者模式
闲云野雀的博客
04-13 311
观察者模式 观察者模式UML 观察者模式是一种对象行为模式。它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
java-观察者模式
qq_40913932的博客
02-20 113
观察者模式 什么叫做观察者模式： 举个例子吧，以前读书的时候上课玩游戏，聊天，撩妹的是不是担心班主任来巡查，这时候是不是会叫一个人去观察班主任来没来？这里的上课开小差的是被通知的人，看班主任来没来的是观察者，同时他需要负责通知开小差的人。班主任是被观察的人。这就是一个很典型的观察者模式。 何时使用： 当一个对象的改变对其他多个对象有影响的话，就可以考虑使用。 注意： 1.避免观察者和观察目标之间循环引用导致系统崩溃 2.如果顺序执行，某一观察者错误或者超时会导致系统卡壳，一般采用异步方式 代码示例： /**
设计模式之观察者模式（Observer）与Java委托
Song's Blog
05-10 1399
1.观察者模式的概念 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。 2.观察者模式的结构图 Subject类：抽象通知者，它把所有对观察者对象的引用保存在一个聚集里，每个通知者都可以有任何数量的观察者。抽象通知者提供一个接口，可以增加和删除观察者对象。 ConcreteSu...
观察者模式
肩上风骋的博客
06-10 110
此文为自己对观察者模式的一些理解与记录，方便后期领悟
观察者设计模式 Vs 事件委托（java）
热门推荐
徐公，微信公众号同名
07-05 1万+
观察者设计模式 Vs 事件委托标签： 设计模式 java 事件的委托本篇博客主要讲解一下几个问题 什么是观察者模式 观察者模式的优缺点 如何看待观察者模式的缺点 事件的委托 什么是观察者模式简单来说，当有多个观察者想同时观察同一个主题对象的时候，当主题对象的 状态发生变化，观察者能够回调自身的方法去更新自己观察者模式的类UML图实现步骤 要定义一个观察者接口 观察者实现观察者接口 要
23种设计模式，纯简单理解，面试必备
最新发布
小电玩
09-20 1521
这意味着无论是处理一个单独的对象还是处理由多个对象组成的复合对象，客户端代码都不需要知道具体的细节，只需要调用同一个接口即可。它们可以独立的变化。具体的实现在代码中也很常见，定义接口类，抽象类进行实现接口类，装饰器类进行继承抽象类进行装饰，这才是完美的符合装饰器设计模式。中介者设计模式的思想就是它能够减少对象之间的依赖关系，使得对象不需要显示地相互引用，从而使耦合性降低，系统易于扩展。在责任链模式中，通常将每个处理者看作一个链表中的节点，每个节点都包含了处理请求的方法以及后继节点的引用。
-(小学音乐教案)三年级上册《儿童团放哨歌》教案.pdf
10-09
-(小学音乐教案)三年级上册《儿童团放哨歌》教案.pdf
java实现事件委托模式的实例详解
08-29
事件委托模式是一种设计模式，它允许对象在不知道对方的存在的情况下进行通信。 Java 实现事件委托模式的实例详解中，我们主要介绍了如何使用 Java 语言来实现事件委托模式，并提供了一个具体的实例来说明如何实现该...
Linux服务器 | 服务器模型与三个模块、两种并发模式：半同步/半异步、领导者/追随者
Jormungand_V的博客
11-21 1183
文章目录C/S模型P2P模型 C/S模型 即常说的 客户端/服务器 模型，将资源（视频、文本、图片、软件等）提供者视作服务器，资源请求者视为客户端。 由于客户端连接请求（connect函数）是随机到达的异步事件，服务器需要使用某种 I/O模型 来监听这一事件。例如 I/O复用技术之一的 select系统调用：当监听到连接请求后，服务器就调用 accept函数 接收它，并分配一个 逻辑单元（新创建的子进程、子线程等） 管理这个新连接。 工作流程如下图所示： 服务器在处理一个客户请求的同时还要继续监听其他客
【设计模式】雷锋依然在人间 --- 工厂方法模式
小田的专栏
06-23 5261
一，概述            工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。  　　工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模
【设计模式】手机软件何时统一 ---- 桥接模式
小田的专栏
07-10 3425
一，概述        定义：将抽象部分与实现部分分离，使它们都可以独立的变化。        在软件系统中，某些类型由于自身的逻辑，它具有两个或多个维度的变化，那么如何应对这种“多维度的变化”？如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化，而又不引入额外的复杂度？这就要使用Bridge模式。        【注意】C++中继承声明为  public   二，示
【设计模式】商场促销 -- 策略模式
小田的专栏
06-18 3211
一，概念         策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。 二，策略模式的组成 　　 1）抽象策略角色： 策略类，通常由一个接口或者抽象类实现。 　　 2）具体策略角色：包装了相关的算法和行为。 　　 3）环境角色：持有一个策略类的引用，最终给客户端调用。 三，补充C++知识 类
【设计模式】简单工厂模式
小田的专栏
06-17 3070
一，概念         从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。 二，实例         请用C++、Java、C#任意一种面向对
【设计模式】为别人做嫁衣 --- 代理模式
小田的专栏
06-22 2065
一，概述         定义：代理模式（Proxy）为另一个对象提供一个替身或占位符以控制对这个对象的访问，简而言之就是用一个对象来代表另一个对象。           作用：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。         思想：为了提供额外的处理或者不同的操作
【设计模式】考题 -- 模板方法模式
小田的专栏
06-27 2035
一，概述         模板方法模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构既可以重定义该算法的某些特定步骤         核心思想：抽象类的方法推迟到子类实现。基类示例指向子类实现 二，示例         老师出考题，学生抄题，然后答题。          1）第一种实现方式                 缺点：学生每次
用C语言编写我们在玩战略性游戏时，可能会遇到这样的情形：为了探测是否有来自敌人的进攻，我们不得不在若干路口安排士兵放哨。假设把道路看成边，路口看成节点，则道路和路口在某次游戏中构成了一棵抽象的“树”。现在的问题是：如何安排最少的士兵并观测到所有边的情况？有多组测试集，每组测试集都是如下一棵树的输入： 首先输入树的节点个数n，接着用n行描述节点之间的关系。节点关系描述为：节点编号:(连接该节点边的数目m) 和该节点相邻的m个节点的编号；如果某节点没有边相连，则描述为: 节点编号:(0)。同一条边只在输入数据中输入一次输出士兵的数量。
06-11
这是一个经典的问题，可以使用贪心算法来解决。具体步骤如下： 1. 任选一个节点作为根节点，并将其标记为已覆盖。 2. 对于根节点的每个子节点，选择一个士兵放在该子节点上，并将其标记为已覆盖。 3. 对于每个未被覆盖的节点，选择其未被覆盖的子节点中深度最大的那个，放置一个士兵在该子节点上，并将其标记为已覆盖。 4. 重复步骤3，直到所有的边都被覆盖。 代码实现如下： ```c #include <stdio.h> #include <stdlib.h> #define MAXN 100005 int n, ans; int head[MAXN], cnt; struct Edge { int to, nxt; } e[MAXN << 1]; inline void addEdge(int u, int v) { e[++cnt] = (Edge){v, head[u]}; head[u] = cnt; } int dfs(int u, int fa) { int maxDepth = 0; for (int i = head[u]; i; i = e[i].nxt) { int v = e[i].to; if (v == fa) continue; int depth = dfs(v, u); if (depth > maxDepth) maxDepth = depth; } if (maxDepth == 0) return 1; else if (maxDepth == 1) { ans++; return 0; } else return maxDepth - 1; } int main() { scanf("%d", &n); for (int i = 1; i < n; i++) { int u, v, m; scanf("%d:(%d)", &u, &m); while (m--) { scanf("%d", &v); addEdge(u, v); addEdge(v, u); } } dfs(1, 0); printf("%d\n", ans); return 0; } ``` 时间复杂度为 $O(n)$。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值