行为型模式

责任链模式

内容:使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。
将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。
角色:
抽象处理者(Handler)
具体处理者(ConcreteHandler)
客户端(Client)

  1. from abc import ABCMeta, abstractmethod
  2.  
  3. class Handler(metaclass=ABCMeta):
  4. @abstractmethod
  5. def handle_leave(self, day):
  6. pass
  7.  
  8. class GeneralManager(Handler):
  9. def handle_leave(self, day):
  10. if day <= 10:
  11. print("总经理准假%d天" % day)
  12. else:
  13. print("你还是辞职吧")
  14.  
  15. class DepartmentManager(Handler):
  16. def __init__(self):
  17. self.next = GeneralManager()
  18.  
  19. def handle_leave(self, day):
  20. if day <= 5:
  21. print("部门经理准假%s天" % day)
  22. else:
  23. print("部门经理职权不足")
  24. self.next.handle_leave(day)
  25.  
  26. class ProjectDirector(Handler):
  27. def __init__(self):
  28. self.next = DepartmentManager()
  29.  
  30. def handle_leave(self, day):
  31. if day <= 3:
  32. print("项目主管准假%d天" % day)
  33. else:
  34. print("项目主管职权不足")
  35. self.next.handle_leave(day)
  36.  
  37. day = 12
  38. h = ProjectDirector()
  39. h.handle_leave(day)

  

适用场景:
有多个对象可以处理一个请求,哪个对象处理由运行时决定
在不明确接收者的情况下,向多个对象中的一个提交一个请求
优点:
降低耦合度:一个对象无需知道是其他哪一个对象处理其请求

观察者模式

内容:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到
通知并被自动更新。观察者模式又称“发布-订阅”模式
角色:
抽象主题(Subject)
具体主题(ConcreteSubject)——发布者
抽象观察者(Observer)
具体观察者(ConcreteObserver)——订阅者

  1. from abc import ABCMeta, abstractmethod
  2.  
  3. class Observer(metaclass=ABCMeta): # 抽象订阅者
  4. @abstractmethod
  5. def update(self, notice): # notice 是一个Notice类的对象,以便过去Notice更新的消息
  6. pass
  7.  
  8. class Notice: # 抽象发布者
  9. def __init__(self):
  10. self.observers = []
  11.  
  12. def attach(self, obs):
  13. self.observers.append(obs) # 添加订阅
  14.  
  15. def detach(self, obs):
  16. self.observers.remove(obs) # 取消订阅
  17.  
  18. def notify(self): # 向订阅者推送消息
  19. for obs in self.observers:
  20. obs.update(self) # 对订阅者的消息进行更新
  21.  
  22. class StaffNotice(Notice): # 具体发布者
  23. def __init__(self, company_info=None):
  24. super().__init__()
  25. self.__company_info = company_info
  26.  
  27. @property
  28. def company_info(self):
  29. return self.__company_info
  30.  
  31. @company_info.setter
  32. def company_info(self, info):
  33. self.__company_info = info
  34. self.notify() # 一有改变就向订阅者发送消息,并调用订阅者的消息更新方法
  35.  
  36. class Staff(Observer):
  37. def __init__(self):
  38. self.company_info = None
  39.  
  40. def update(self, notice): # 获取消息更新的方法
  41. self.company_info = notice.company_info
  42.  
  43. # Client
  44.  
  45. notice = StaffNotice("初始公司信息")
  46.  
  47. s1 = Staff()
  48. s2 = Staff()
  49.  
  50. notice.attach(s1)
  51. notice.attach(s2)
  52.  
  53. notice.company_info = "公司今年业绩非常好,给大家发奖金!!!"
  54. print(s1.company_info)
  55. print(s2.company_info)
  56. notice.detach(s2)
  57. notice.company_info = "公司明天放假!!!"
  58. print(s1.company_info)
  59. print(s2.company_info)
  60.  
  61. """
  62. 公司今年业绩非常好,给大家发奖金!!!
  63. 公司今年业绩非常好,给大家发奖金!!!
  64. 公司明天放假!!!
  65. 公司今年业绩非常好,给大家发奖金!!!
  66.  
  67. """

  

适用场景:
当一个抽象模型有两方面,其中一个方面依赖于另一个方面。将这两者封装在独立对象中以使它们可以各自独立地改变和
复用。
当对一个对象的改变需要同时改变其它对象,而不知道具体有多少对象有待改变。
当一个对象必须通知其它对象,而它又不能假定其它对象是谁。换言之,你不希望这些对象是紧密耦合的。
优点:
目标和观察者之间的抽象耦合最小
支持广播通信

策略模式

内容:定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使
得算法可独立于使用它的客户而变化。
角色:
抽象策略(Strategy)
具体策略(ConcreteStrategy)
上下文(Context)

  1. from abc import ABCMeta, abstractmethod
  2.  
  3. class Strategy(metaclass=ABCMeta):
  4. @abstractmethod
  5. def execute(self, data):
  6. pass
  7.  
  8. class FastStrategy(Strategy):
  9. def execute(self, data):
  10. print("用较快的策略处理%s" % data)
  11.  
  12. class SlowStrategy(Strategy):
  13. def execute(self, data):
  14. print("用较慢的策略处理%s" % data)
  15.  
  16. class Context:
  17. def __init__(self, strategy, data): # 将对数据处理的方法封装起来
  18. self.data = data
  19. self.strategy = strategy
  20.  
  21. def set_strategy(self, strategy): #设置策略
  22. self.strategy = strategy
  23.  
  24. def do_strategy(self): # 执行策略的方法
  25. self.strategy.execute(self.data)
  26.  
  27. data = "[...]"
  28. s1 = FastStrategy()
  29. s2 = SlowStrategy()
  30. context = Context(s1, data)
  31. context.do_strategy()
  32. context.set_strategy(s2)
  33. context.do_strategy()

  

优点:
定义了一系列可重用的算法和行为
消除了一些条件语句
可以提供相同行为的不同实现
缺点:
客户必须了解不同的策略

模板方法模式

内容:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。模板方法
使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
角色:
抽象类(AbstractClass):定义抽象的原子操作(钩子操作);实现一个模
板方法作为算法的骨架。
具体类(ConcreteClass):实现原子操作

  1. from abc import ABCMeta, abstractmethod
  2. from time import sleep
  3.  
  4. class Window(metaclass=ABCMeta):
  5. @abstractmethod
  6. def start(self):
  7. pass
  8.  
  9. @abstractmethod
  10. def repaint(self):
  11. pass
  12.  
  13. @abstractmethod
  14. def stop(self): # 原子操作/钩子操作
  15. pass
  16.  
  17. def run(self): # 模板方法
  18. self.start()
  19. while True:
  20. try:
  21. self.repaint()
  22. sleep(1)
  23. except KeyboardInterrupt:
  24. break
  25. self.stop()
  26.  
  27. class MyWindow(Window):
  28. def __init__(self, msg):
  29. self.msg = msg
  30.  
  31. def start(self):
  32. print("窗口开始运行")
  33.  
  34. def stop(self):
  35. print("窗口结束运行")
  36.  
  37. def repaint(self):
  38. print(self.msg)
  39.  
  40. MyWindow("Hello...").run()

  

适用场景:
一次性实现一个算法的不变的部分
各个子类中的公共行为应该被提取出来并集中到一个公共父类中以
避免代码重复
控制子类扩展

sjms-4 行为型模式的更多相关文章

  1. 工厂方法模式——创建型模式02

    1. 简单工厂模式     在介绍工厂方法模式之前,先介绍一下简单工厂模式.虽然简单工厂模式不属于GoF 23种设计模式,但通常将它作为学习其他工厂模式的入门,并且在实际开发中使用的也较为频繁. (1 ...

  2. 单例模式——创建型模式01

    1. 名称     单例模式(Singleton Pattern):确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类.单例模式是一种对象创建型模式. 2. 问题    ...

  3. C#面向对象设计模式纵横谈——2.Singleton 单件(创建型模式)

    一:模式分类 从目的来看: 创建型(Creational)模式:负责对象创建. 结构型(Structural)模式:处理类与对象间的组合. 行为型(Behavioral)模式:类与对象交互中的职责分配 ...

  4. Java设计模式之行为型模式

    行为型模式共11种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.访问者模式.中介者模式.解释器模式. 策略模式:策略模式的决定权在用户,系统本身提供不同 ...

  5. Java设计模式之创建型模式

    创建型模式分为五类:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式 一.工厂方法模式:接口-实现类.工厂类

  6. 设计模式之美:Behavioral Patterns(行为型模式)

    行为型模式涉及到算法和对象间职责的分配. 行为模式不仅描述对象或类的模式,还描述它们之间的通信模式. 这些模式刻划了在运行时难以跟踪的复杂的控制流.它们将你的注意力从控制流转移到对象间的联系方式上来. ...

  7. 第28章 行为型模式大PK

    27.1 策略模式 VS 命令模式 27.1.1 策略模式实现压缩算法 //行为型模式大PK——策略模式和命令模式 //实例:用策略模式实现压缩算法 #include <iostream> ...

  8. 第26章 创建型模式大PK

    26.1 工厂方法模式 VS 建造者模式 26.1.1 按工厂方法建造超人 (1)产品:两类超人,成年超人和未成年超人. (2)工厂:这里选择简单工厂 [编程实验]工厂方法建造超人 //创建型模式大P ...

  9. 设计模式学习之备忘录模式(Memento,行为型模式)(19)

    假如我们已经记录一个人的个人信息,但是发现信息写错了,然后我先备份下再去修改,结果发现原来的信息是正确的,于是我就看备份的个人信息还原到初始的状态,下面我们用代码去实现 class Program { ...

  10. 设计模式学习之命令模式(Command,行为型模式)(12)

    一.命令模式的定义 命令模式属于对象的行为型模式.命令模式是把一个操作或者行为抽象为一个对象中,通过对命令的抽象化来使得发出命令的责任和执行命令的责任分隔开.命令模式的实现可以提供命令的撤销和恢复功能 ...

随机推荐

  1. [转载]EF或LINQ 查询时使用IN并且根据列表自定义排序方法

    原文地址:EF或LINQ 查询时使用IN并且根据列表自定义排序方法作者:李明川 EF和LINQ改变了原有的手写SQL时期的一些编码方法,并且增强了各数据库之间的移植性简化了开发时的代码量和难度,由于很 ...

  2. keil的自动补全功能

    设置完之后,在.c文件上试一下,发现还是不能自动补全. 后来去各种贴吧里找到了答案,是我的.c文件还没有保存到工程文件中去,所以不能实现这个功能.

  3. pyton 模块之 pysmb 文件上传(windows)

    #!/usr/bin/env python #coding:utf-8 from smb.SMBConnection import SMBConnection from nmb.NetBIOS imp ...

  4. 多功能网页刷新工具,刷pv工具

    多功能网页刷新工具,刷pv工具,在线刷流量,刷PV,刷UV小牛刷新助手功能介绍:1.设置多个刷新网页地址.2.设置刷新时间3.开始工作4.其他操作:老板键:打开时自动刷新:置系统托盘5.可手动输入地址 ...

  5. UniRX简述

    UniRX:是一个Unit3D的编程框架,专注于解决异步逻辑,使得异步逻辑的实现更加简单优雅. 例如:实现“只处理第一次鼠标点击事件”: Observable.EveryUpdate() .Where ...

  6. centos7 安装memcached

    (1)编译安装Memcached 1.51.1 安装依赖包libevent# yum -y install epel-release# yum -y install libevent libevent ...

  7. React中this.props的主要属性

    this.props主要包含:history属性.location属性.match属性 ①history属性又包含 ②location属性又包含 ③match属性又包含

  8. # 2018-2019-20175302实验一《Java开发环境的熟悉》实验报告

    2018-2019-20175302实验一<Java开发环境的熟悉>实验报告 实验内容 1.使用JDK编译.运行简单的Java程序: 2.使用Eclipse 编辑.编译.运行.调试Java ...

  9. 51单片机学习笔记(郭天祥版)(6)——键盘的作业题、AD、DA、DS18B20(这里之后看清翔的补一下好了)

    A:analog,D:digital AD,就是模拟量转换为数字量,DA就是数字量转换为模拟量 为什么要转换? 单片机是数字芯片,内部只有0和1,没法表示模拟量 比如我们如果需要2.5V怎么办?其实是 ...

  10. docker run 与docker start的区别

    docker run相当于执行了两步操作:将镜像放入容器中(docker create),然后将容器启动,使之变成运行时容器(docker start). 而docker start的作用是,重新启动 ...