python 观察者模式

参考博客   https://www.cnblogs.com/Xjng/p/4038931.html

       在制作自己的音乐播放器的时候遇到这个问题，我需要键盘监听来得到用户的输入来判断程序是暂停播放还是切换下一首歌亦或是进行倍速播放，本来是打算使用多线程来解决的，可是经过认真仔细的考虑，从cpu的角度看，多线程只是线程占用了不同的时间片而已，单位时间内还是只能有一个线程执行操作，但是如果应用到音乐播放器，我们不能一边执行音乐播放，一边进行键盘监听，最后查阅资料，得到这个观察者设计模式。

        由上面的博客可以得出，观察者模式有点像得到消息-进行通知-改变状态这样的过程，比如员工本来在玩手机，而前台看到老板来了之后，改变自己的状态，并把这个消息进行通知，最终员工改变状态。

        那么这里的老板类似于我们监听到的用户的操作，键盘监听程序类似于前台，而最后执行操作类似于员工。

#!/usr/bin/env python35
# -*- coding: utf-8 -*-
# @Time    : 2019/7/6 11:02
# @Author  : MHZ
# @FileName: Observe.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/m0_37428263

#观察者设计模式
#该设计模式类似于公司前台看到老板来了通知员工停止看股票，类似于从键盘输入一个值，让键盘监听得到后，通知音乐播放停止或暂停

#前台类
class Reception():
    Oberserves = []
    status = ''
    name = ''
    #构造方法
    def __init__(self,name):
        # self.Oberserves = []
        # self.status = ''
        self.name = name
    def attach(self,ober):
        self.Oberserves.append(ober)
    def notify(self):
        self.status = 'not good'
        for i in self.Oberserves:
            i.update()

#观察者
class oberserve():
    reception = Reception('')
    def __init__(self,name,reception):
        self.name = name
        self.reception = reception
    def update(self):
        if self.reception.status == 'not good':
            print(self.name + '停止看股票')


if __name__=='__main__':

    reception = Reception('前台')
    ob1 = oberserve('张三',reception)
    ob2 = oberserve('李四',reception)
    reception.attach(ob1)
    reception.attach(ob2)

    reception.status = 'the boss is coming'
    reception.notify()

当遇到这种紧耦合的情况时，就需要将它们耦合的部分抽象成一个父类，这样后期维护就会轻松很多。

注意python3中super()方法的运用

# #!/usr/bin/env python35
# # -*- coding: utf-8 -*-
# # @Time    : 2019/7/6 11:02
# # @Author  : MHZ
# # @FileName: Observe.py
# # @Software: PyCharm
# # @Blog    ：https://blog.csdn.net/m0_37428263

#对于观察者设计模式中紧耦合的现象，可以将耦合部分抽象成一个父类，方便后期维护
from abc import abstractmethod,ABCMeta

class Subject():                #前台类父类
    def __init__(self):
        self.Obverse = []
        self.status = ''
    @abstractmethod
    def attach(self,obverse):
        pass
    @abstractmethod
    def reduceattach(self,obverse):
        pass
    @abstractmethod
    def notify(self):
        pass

class ObservesFather(object):                 #执行类父类
    def __init__(self,name,response,boss):
        self.name = name
        self.response = response
        self.boss = boss
    @abstractmethod
    def update(self):
        pass

class Boss(Subject):
    def __init__(self):
        super(Boss,self).__init__()
    def attach(self,obverse):
        self.Obverse.append(obverse)
    def reduceattach(self,obverse):
        self.Obverse.remove(obverse)
    def notify(self):
        self.status = 'boss is coming'
        for i in self.Obverse:
            i.update()
class Obverse(ObservesFather):
    def __init__(self,name,response,boss):
        super(Obverse,self).__init__(name,response,boss)
    def update(self):
        print(self.name+'停止'+self.response+',开始工作')

if __name__ == '__main__':
    boss = Boss()
    NBAObverse = Obverse('mhz','看NBA',boss)
    PlayGameObverse = Obverse('yxk','打游戏',boss)
    boss.attach(NBAObverse)
    boss.attach(PlayGameObverse)
    boss.notify()