观察者模式

最新推荐文章于 2021-12-09 21:39:16 发布
最新推荐文章于 2021-12-09 21:39:16 发布
阅读量156 收藏 1
点赞数
分类专栏： 设计模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanshan1111/article/details/89329735
版权

目录

一、观察者模式

二、观察者模式角色

1、抽象主题

2、抽象观察者

3、具体主题

4、具体观察者

四、应用

五、代码实例一

六、代码实例二

七、C#中的委托事件机制

一、观察者模式

观察者模式实现了观察者与目标之间的抽象耦合、动态联动。

例如 知乎、微博、外卖等软件，当有新的热门信息、我们经常浏览的信息更新时，手机上经常会受到信息。我们就是观察者，而这些软件就像是目标。当信息更新时，我们会接受到提示信息，当我们取消一些订阅时，一些信息就不会被推送。

本质是触发联动

别名：

1、发布-订阅模式

2、模型-视图模式

3、源-监听器模式

4、从属者模式

模式如其名。

二、观察者模式角色

1、抽象主题

一个目标可以被多个观察者观察，下面的例子中的员工--老板就是n--1；

目标提供对观察者的增加和删除，如下文中的subject。

当目标的状态发生变化时，目标负责通知所有现存的观察者。

2、抽象观察者

为所有的具体观察者提供一个接口。

有一个更新接口，方便更新新的信息。

3、具体主题

将有关状态存入具体观察者对象。在状态发生变化时，负责给所有所属的观察者发送消息。

因此又被叫做具体被观察者角色。

4、具体观察者

要实现具体更新接口。

还可以有一个指向具体主题对象的引用。

如下文中的Stock和Dba。

四、应用

使系统耦合度降低，便于复用。

要使低耦合度的对象能协调工作。

五、代码实例一

同事间帮忙。

第一个类：抽象主题类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__通知信息
{
    interface  Subject
    {
        void Attach(Observer obs);
        void Detach(Observer obs);
        void Notify();
        String SubjectState 
        {
            get;
            set;
        }

    }
}

第二个类：抽象观察者

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__通知信息
{
    abstract class Observer
    {
        protected string name;
        protected Subject sub;

        protected Observer(string name, Subject sub)
        {
            this.name = name;
            this.sub = sub;
        }
        public abstract void update();
    }
}

 第三个类：具体主题类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__通知信息
{
    class Subject_Secretary : Subject
    {
        private IList<Observer> observers = new List<Observer>();
        private string action;
        public string SubjectState
        {
            get { return action; }
            set { action = value; }
        }
        public void Attach(Observer obs)
        {
            observers.Add(obs);
        }

        public void Detach(Observer obs)
        {
            observers.Remove(obs);
        }

        public void Notify()
        {
            foreach(Observer o in observers)
            {
                o.update();
            }
        }
    }
}

第四、五个类：具体观察者类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__通知信息
{
    class Stock_Observer : Observer
    {
        public Stock_Observer(string name, Subject sub) : base(name, sub) { }
        public override void update()
        {
            Console.WriteLine("{0}{1}关闭股票，继续工作", sub.SubjectState, name);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__通知信息
{
    class Nba_Observer : Observer
    {
        public Nba_Observer(string name, Subject sub) : base(name, sub) { }
        public override void update()
        {
            Console.WriteLine("{0}{1}停止看球，继续工作", sub.SubjectState, name);
        }
    }
}

测试类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__通知信息
{
    class Program
    {
        static void Main(string[] args)
        {
            Subject_Secretary L1 = new Subject_Secretary();
            Stock_Observer S1 = new Stock_Observer("S1",L1);
            Nba_Observer N1 = new Nba_Observer("N1", L1);
            L1.Attach(S1);
            L1.Attach(N1);
            L1.SubjectState = "老板来了";
            L1.Notify();
        }
    }
}

六、代码实例二

一个股票的例子

第一个类：一个抽象的股票类

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__股票行情
{
    abstract class Stock
    {
        protected string symbol;
        protected double price;
        private ArrayList investors = new ArrayList();

        protected Stock(string symbol, double price)
        {
            this.symbol = symbol;
            this.price = price;
        }
        public void Attach(IInvestor inv)
        {
            investors.Add(inv);
        }
        public void Detach(IInvestor inv)
        {
            investors.Remove(inv);
        }
        public void Notify()
        {
            foreach(IInvestor i in investors)
            {
                i.update(this);
            }
                
        }
        public double Price
        {
            get { return price; }
            set { price = value; Notify(); }
        }
        public string Symbol
        {
            get { return symbol; }
            set { symbol = value; }
        }
    }
}

第二个类：观察者接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__股票行情
{
    interface  IInvestor
    {
        void update(Stock stock);
    }
}

第三个类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__股票行情
{
    class Investor_One : IInvestor
    {
        private string name;
        private string ObserveState;
        private Stock stock;

        public Investor_One(string name)
        {
            this.name = name;
        }


        public void update(Stock stock)
        {
            Console.WriteLine("Notified investor {0} of {1}'s change to {2:C}", name, stock.Symbol, stock.Price);
        }
        public Stock Stock
        {
            get { return stock; }
            set { stock = value; }
        }
    }
}

第四个类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__股票行情
{
    class IBM:Stock
    {
        public IBM(string symbol,double price):base(symbol, price) { }
       
    }
}

第五个测试类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__股票行情
{
    class Program
    {
        static void Main(string[] args)
        {
            Investor_One i1 = new Investor_One("i1");
            Investor_One i2 = new Investor_One("i2");
            IBM ibm = new IBM("IBM", 200.1);
            ibm.Attach(i1);
            ibm.Attach(i2);
            ibm.Price = 201;
            ibm.Price = 101.9;
        }
    }
}

七、C#中的委托事件机制

delegate void UpdateDelegate()是定义一个委托，下面两个观察者的更新函数都符合这个委托。

public event UpdateDelegate UpdateHandler定义事件，一旦事件被触发，就会调用一组 UpdateDelegate()规范的方法。

+号就可以实现添加事件功能。

UpdateHandler不为空时，代表有订阅者，就会调用UpdateHandler（）

主题类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__委托
{
    delegate void UpdateDelegate();//委托对象
    class Subject
    {
        public event UpdateDelegate UpdateHandler;
        public void Attach(UpdateDelegate ud)
        {
            UpdateHandler += ud;
        }
        public void Detach(UpdateDelegate ud)
        {
            UpdateHandler -= ud;
        }
        public void Notify()
        {
            if (UpdateHandler != null)
                UpdateHandler();//委托事件
        }

    }
}

真实主题类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__委托
{
    class ConcreteSubject:Subject
    {
        private string subjectState;
        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
    }
}

观察者类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__委托
{
    class ConcreteObserver
    {
        private string name;
        private string observerState;
        private ConcreteSubject subject;

        public ConcreteObserver(string name, ConcreteSubject subject)
        {
            this.name = name;
            this.subject = subject;
        }
        public void update()
        {
            observerState = subject.SubjectState;
            Console.WriteLine("observer {0} s new state is{1}", name, observerState);
        }
        public ConcreteSubject Subject
        {
            get { return subject; }
            set { subject = value; }
        }
    }
}

另一个观察者类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__委托
{
    class ConcreteObserver_Another
    {
        public void show()
        {
            Console.WriteLine("AnotherObserver got an Notification!");
        }
    }
}

测试类 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式__委托
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteSubject cs = new ConcreteSubject();
            ConcreteObserver c1 = new ConcreteObserver("c1",cs);
            ConcreteObserver c2 = new ConcreteObserver("c2", cs);
            ConcreteObserver_Another c3 = new ConcreteObserver_Another();
            cs.Attach(new UpdateDelegate(c1.update));
            cs.Attach(new UpdateDelegate(c2.update));
            cs.Attach(new UpdateDelegate(c3.show));
            cs.SubjectState = "啊哈哈哈哈";
            cs.Notify();
            Console.WriteLine("------------");
            cs.Detach(new UpdateDelegate(c3.show));
            cs.Notify();




        }
    }
}

猫大叫一声，所有的老鼠都开始逃跑，主人被惊醒。

代码实例：

抽象主题：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverOne
{
    abstract class Subject
    {
        public string State { get ; set ; }
        abstract public void Attach(UpdateDelegate a); 
        abstract public void Detach(UpdateDelegate a);
        abstract public void Notify();
    }
}

具体主题：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverOne
{
    delegate void UpdateDelegate();
    class CatSubject:Subject
    {
        private string state;
        public event UpdateDelegate UpdateHandler;
        public string State { get => state; set => state = value; }

        public override void Attach(UpdateDelegate a)
        {
            UpdateHandler += a;//---
        }

        public override void Detach(UpdateDelegate a)
        {
            UpdateHandler -= a;
        }

        public override void Notify()
        {
            if (UpdateHandler != null) UpdateHandler();
        }
    }
}

抽象观察者：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverOne
{
    abstract class ObserverPlus
    {
        protected string name;
        protected Subject subject;

        protected ObserverPlus(string name, Subject subject)
        {
            this.name = name;
            this.subject = subject;
        }
        public abstract void update();
    }
}

具体：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverOne
{
    class MouseObserverPlus : ObserverPlus
    {
        private CatSubject c = new CatSubject();
        public MouseObserverPlus(string name,CatSubject subject) : base(name, subject) { c = subject; }

        public override void update()
        {
            Console.WriteLine("{0}....{1}来了快跑！", c.State,name);
           // Console.WriteLine(subject.State+"---");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ObserverOne
{
    class PersonObserver : ObserverPlus
    {
        private CatSubject c=new CatSubject();
        public PersonObserver(string name,CatSubject subject) : base(name, subject) { c = subject; }
        public override void update()
        {
            Console.WriteLine("{0}....来了{1}惊醒了！", c.State, name);
        }
    }
}

测试：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace ObserverOne
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {
            //CatSubject cat = new CatSubject();
            //MouseObserver m1 = new MouseObserver("Tom", cat);
            //cat.Attach(new UpdateDelegate(m1.update));
            //cat.State = "猫马上来";
            //cat.Notify();
            //cat.State = "猫来了";
            //cat.Notify();//-----//-----//-----//----
            CatSubject cat = new CatSubject();
            MouseObserverPlus m1 = new MouseObserverPlus("猫", cat);
            cat.Attach(new UpdateDelegate(m1.update));
            cat.State = "马上";
            cat.Notify();
            cat.State = "现在";
            cat.Notify();
            PersonObserver p1 = new PersonObserver("小明", cat);
            cat.Attach(new UpdateDelegate(p1.update));
            cat.Notify();

        }
    }
}

 

桑榆207
关注
专栏目录
观察者模式的例子(java)
12-05
.java文件。观察者模式的例子。可以运行，同时帮助理解观察者模式。
常用的设计模式 - 观察者模式（Observer模式）
×6
09-27 475
观察者（Observer）模式的定义： 指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。 观察者模式是一种对象行为型模式，其主要优点如下： 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。 目标与观察者之间建立了一套触发机制。 缺点如下： 目标与观察者之间的...
观察者模式简单例子
sehnsucht
06-12 185
观察者模式 核心:在抽象类里有一个 ArrayList 存放观察者们 代码不算完整,那个table的展示省略 package com.cai.observer; import java.util.ArrayList; import java.util.List; /** * @Description * @Author Cai * @Create 2021-06-12-15:34 */ interface Table { void show(); void notifyData
观察者模式 实例
weixin_30362083的博客
07-07 451
观察者模式在软件重构中会常常被使用，下面写出一个实例便于理解.. 代码 1 using System; 2 using System.Collections; 3 4 namespace moniter 5 { 6 public interface objserver 7 { 8 void Action(); 9 }10...
观察者模式例子
Meng_You_Lin的博客
12-04 382
观察者模式中有一个气象观测站的例子，此系统中的三个部分是气象站（获取实际气象数据的物理装置），WeatherData对象（追踪来自气象站的数据，并更新）和布告板（显示气象状况给用户看）。 WeatherData对象就是一个主题，获取更新的数据，通知并更新它下面的三个布告板。我要做的就是建议一个应用，利用WeatherData对象获取数据，并更新三个布告板。 WeatherData有getter
用C++ 实现设计模式之观察者模式
12-22
观察者模式是一种软件设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式在处理事件驱动和实时信息更新的系统中非常常见，如股票市场的...
PHP 设计模式之观察者模式介绍
10-28
观察者模式是软件设计模式中的一种行为模式，它允许一个对象（称为主题或可观察者）在状态发生改变时通知其他对象（称为观察者）。这种模式遵循了几个重要的设计原则，如开放封闭原则、依赖倒置原则和组合复用原则，...
iOS 设计模式 观察者模式
02-18
观察者模式，也被称为发布-订阅（Publish-Subscribe）模式，是软件设计中的一种行为模式。在iOS开发中，它是一种让多个对象监听或订阅某一个主题对象的状态变化，并在状态变化时自动收到通知的方式。这种模式使得...
JAVA中常用的设计模式：单例模式，工厂模式，观察者模式
08-19
观察者模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于事件驱动编程，例如GUI组件、订阅-发布系统等。 ```...
举一个简单的例子，轻松搞懂所谓的“观察者模式”
m0_56058975的博客
12-09 737
看上面那些可能不太容易理解，简单举个例子，假如有一个产品列表，当这个产品列表更新的时候就会同步到一些电商平台，最简单的可能会用if进行判断，当产品列表更新就同步，例如下图：
一个简单明了的观察者模式案例
sun_surprise的博客
07-06 1612
这几天一直在学习设计模式这方面，单例模式，简单工厂模式，观察者模式这三个比较简单易懂的设计模式，今天先说说观察者模式。这是用事件来响应。场景中建两个球，当一个球下落到地面的时候，另一个球弹起往上运动。public class ObjectBall : MonoBehaviour {      public event EventHandler&lt;EventArgs&gt; BallDownEv...
设计模式之-观察者模式示例（个人笔记）
wangjw.bug
09-23 2067
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、什么是观察者模式？二、使用场景（菜鸟教程）二、示例 一、什么是观察者模式？ 观察者模式是软件设计模式的一种，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知——百度百科。 二、使用场景（菜鸟教程） 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变
观察者模式-精简举例阐释
IT从业者
10-04 511
1.概念 观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式; 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象;这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。 模式定义了一
观察者模式举例【转】
Jerry_liu20080504的专栏
03-10 1183
http://jasonshieh.javaeye.com/blog/726557package observe;import java.util.Vector;interface Observer { public void update();}interface Subject { public void attach(Observer o); public void detach(Observer o); public void notice();}class Teacher implements S
java设计模式之观察者模式及简单示例举例
qq_42160683的博客
11-23 487
java设计模式之观察者模式 模式的定义与特点 观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。 观察者模式是一种对象行为型模式，其主要优点如下。 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。 目标与观察者之间建立了一套触...
java观察者模式举例
郑海波(莫川)的CSDN博客
11-13 2135
简介 观察者模式（有时又被称为发布-订阅Subscribe>模式、模型-视图View>模式、源-收听者Listener>模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。 我一向都是例子驱动学习，一下简单的举一个例子。 例子的逻
观察者模式理解及实例
个人工作中学到的专业技术与职业发展知识笔记
12-13 877
实例： #include <iostream> #include <list> #include <string> #include <vector> // 观察者基类，提供供发布者调用的通用接口Update()函数； class IObserver { public: virtual ~IObserver() {}; virtual void Update(const std::string &message) = 0; }; // 发布者基
观察者模式简介及使用示例
。鲸落
06-10 6091
文章目录观察者模式简介使用示例总结优缺点使用场景扩展联想学习 观察者模式简介 观察者模式又叫发布订阅（Publish/Subscribe）模式 观察者模式（Observer Pattern）定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。 类图： 核心类说明： Subject： 抽象主题，即为被观...
观察者模式详解与应用
"观察者模式" 观察者模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动编程或者实时数据更新的场景...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值