設計模式-行爲型模式

時間 2019-12-10

標籤設計模式行爲简体版

原文原文鏈接

模板方法模式算法

# 好多行爲小步驟不同，框架是同樣的，將框架抽離出來

"""
內容：
    定義一個操做中的算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類能夠不改變一個算法的結構便可重定義該算法的某些特定步驟。
角色：
    抽象類（AbstractClass）：定義抽象的原子操做（鉤子操做）；實現一個模板方法做爲算法的骨架。
    具體類（ConcreteClass）：實現原子操做
適用場景：
    一次性實現一個算法的不變的部分
    各個子類中的公共行爲應該被提取出來並集中到一個公共父類中以免代碼重複
    控制子類擴展
"""

代碼實例app

from abc import ABCMeta, abstractmethod


class IOHandler(metaclass=ABCMeta):
    @abstractmethod
    def open(self, name):
        pass

    @abstractmethod
    def deal(self, change):
        pass

    @abstractmethod
    def close(self):
        pass

    # 模板方法
    def process(self, name, change):
        self.open(name)
        self.deal(change)
        self.close()


class FileHandler(IOHandler):
    def open(self, name):
        self.f = open(name, 'w')

    def deal(self, change):
        self.f.write(change)

    def close(self):
        self.f.close()


f = FileHandler()
f.process("a.txt", 'abc')

責任鏈模式框架

"""
內容：
    使多個對象都有機會處理請求，從而避免請求的發送者和接收者之間的耦合關係。將這些對象連成一條鏈，並沿着這條鏈傳遞該請求，直到有一個對象處理它爲止。
角色：
    抽象處理者（Handler）
    具體處理者（ConcreteHandler）
    客戶端（Client）
例：
    請假部門批准：leader部門經理總經理
    Javascript事件浮升機制

適用場景：
    有多個對象能夠處理一個請求，哪一個對象處理由運行時決定
    在不明確接收者的狀況下，向多個對象中的一個提交一個請求
優勢：
    下降耦合度：一個對象無需知道是其餘哪個對象處理其請求
缺點：
    請求不保證被接收：鏈的末端沒有處理或鏈配置錯誤

"""

代碼實現dom

from abc import ABCMeta, abstractmethod


class Handler(metaclass=ABCMeta):
    @abstractmethod
    def handle_leave(self, day):
        pass


class GeneralManagerHandler(Handler):
    def handle_leave(self, day):
        if day < 10:
            print("總經理批准%d天假" % day)
        else:
            print("呵呵")


class DepartmentManagerHandler(Handler):
    def __init__(self):
        self.successor = GeneralManagerHandler()

    def handle_leave(self, day):
        if day < 7:
            print("部門經理批准%d天假" % day)
        else:
            print("部門經理無權准假")
            self.successor.handle_leave(day)


class ProjectDirectorHandler(Handler):
    def __init__(self):
        self.successor = DepartmentManagerHandler()

    def handle_leave(self, day):
        if day < 3:
            print("項目主管批准%d天假")
        else:
            print("項目主管無權准假")
            self.successor.handle_leave(day)


day = 6
h = ProjectDirectorHandler()
h.handle_leave(day)

# --高級例子--模仿js事件處理

class Handler(metaclass=ABCMeta):
    @abstractmethod
    def add_event(self, func):
        pass

    @abstractmethod
    def handle(self):
        pass


class BodyHandler(Handler):
    def __init__(self):
        self.func = None

    def add_event(self, func):
        self.func = func

    def handle(self):
        if self.func:
            return self.func()
        else:
            print("已到最後一級，沒法處理")


class ElementHandler(Handler):
    def __init__(self, successor):
        self.func = None
        self.successor = successor

    def add_event(self, func):
        self.func = func

    def handle(self):
        if self.func:
            return self.func()
        else:
            return self.successor.handle()


# 客戶端

# <body><div><a>

body = {'type': 'body', 'name': 'body', 'children': [], 'father': None}

div = {'type': 'div', 'name': 'div', 'children': [], 'father': body}

a = {'type': 'a', 'name': 'a', 'children': [], 'father': div}

body['children'].append(div)
div['children'].append(a)

body['event_handler'] = BodyHandler()
div['event_handler'] = ElementHandler(div['father']['event_handler'])
a['event_handler'] = ElementHandler(a['father']['event_handler'])

def attach_event(element, func):
    element['event_handler'].add_event(func)

#test

def func_div():
    print("這是給div的函數")

def func_a():
    print("這是給a的函數")

def func_body():
    print("這是給body的函數")

#attach_event(div, func_div)
#attach_event(a, func_a)
#attach_event(body, func_body)


a['event_handler'].handle()

觀察者模式函數

# 又稱「發佈-訂閱」模式，發佈者消息更新，訂閱者要跟着更新

"""
內容：
    定義對象間的一種一對多的依賴關係,當一個對象的狀態發生改變時, 
    全部依賴於它的對象都獲得通知並被自動更新。觀察者模式又稱「發佈-訂閱」模式
角色：
    抽象主題（Subject）
    具體主題（ConcreteSubject）——發佈者
    抽象觀察者（Observer）
    具體觀察者（ConcreteObserver）——訂閱者
適用場景：
    當一個抽象模型有兩方面，其中一個方面依賴於另外一個方面。將這二者封裝在獨立對象中以使它們能夠各自獨立地改變和複用。
    當對一個對象的改變須要同時改變其它對象，而不知道具體有多少對象有待改變。
    當一個對象必須通知其它對象，而它又不能假定其它對象是誰。換言之，你不但願這些對象是緊密耦合的。
優勢：
    目標和觀察者之間的抽象耦合最小
    支持廣播通訊
缺點：
    多個觀察者之間互不知道對方存在，所以一個觀察者對主題的修改可能形成錯誤的更新。
"""

代碼實現ui

from abc import ABCMeta, abstractmethod


class Observer(metaclass=ABCMeta):  # 訂閱者/觀察者
    @abstractmethod
    def update(self, notice):
        pass


class Notice:  # 發佈者
    def __init__(self):
        self.observers = []  # 訂閱者列表

    def attach(self, obs):  # 訂閱
        self.observers.append(obs)

    def detach(self, obs):  # 取消訂閱
        self.observers.remove(obs)

    def notify(self):
        for obj in self.observers:
            obj.update(self)


class ManagerNotice(Notice):
    def __init__(self, company_info=None):
        super().__init__()
        self.__company_info = company_info

    @property
    def company_info(self):
        return self.__company_info

    @company_info.setter
    def company_info(self, info):
        self.__company_info = info
        self.notify()


class Manager(Observer):
    def __init__(self):
        self.company_info = None

    def update(self, noti):
        self.company_info = noti.company_info


notice = ManagerNotice()

alex = Manager()
wusir = Manager()

print(alex.company_info)
print(wusir.company_info)

notice.attach(alex)
notice.attach(wusir)

notice.company_info = "公司運行良好"
#
print(alex.company_info)
print(wusir.company_info)
#
notice.detach(wusir)
#
notice.company_info = "公司要破產了"
#
print(alex.company_info)
print(wusir.company_info)

策略模式spa

# 多個策略能夠相互替換

"""
內容：
    定義一系列的算法，把它們一個個封裝起來，而且使它們可相互替換。本模式使得算法可獨立於使用它的客戶而變化。
角色：
    抽象策略（Strategy）
    具體策略（ConcreteStrategy）
    上下文（Context）
適用場景：
    許多相關的類僅僅是行爲有異
    須要使用一個算法的不一樣變體
    算法使用了客戶端無需知道的數據
    一個類中的多種行爲以多個條件語句的形式存在，能夠將這些行爲封裝如不一樣的策略類中。
優勢：
    定義了一系列可重用的算法和行爲
    消除了一些條件語句
    能夠提供相同行爲的不一樣實現
缺點：
    客戶必須瞭解不一樣的策略
    策略與上下文之間的通訊開銷
    增長了對象的數目
"""

代碼實現code

from abc import ABCMeta, abstractmethod
import random


class Sort(metaclass=ABCMeta):
    @abstractmethod
    def sort(self, data):
        pass


class QuickSort(Sort):
    def quick_sort(self, data, left, right):
        if left < right:
            mid = self.partition(data, left, right)
            self.quick_sort(data, left, mid - 1)
            self.quick_sort(data, mid + 1, right)

    def partition(self, data, left, right):
        tmp = data[left]
        while left < right:
            while left < right and data[right] >= tmp:
                right -= 1
            data[left] = data[right]
            while left < right and data[left] <= tmp:
                left += 1
            data[right] = data[left]
        data[left] = tmp
        return left

    def sort(self, data):
        print("快速排序")
        return self.quick_sort(data, 0, len(data) - 1)


class MergeSort(Sort):
    def merge(self, data, low, mid, high):
        i = low
        j = mid + 1
        ltmp = []
        while i <= mid and j <= high:
            if data[i] <= data[j]:
                ltmp.append(data[i])
                i += 1
            else:
                ltmp.append(data[j])
                j += 1

        while i <= mid:
            ltmp.append(data[i])
            i += 1

        while j <= high:
            ltmp.append(data[j])
            j += 1

        data[low:high + 1] = ltmp

    def merge_sort(self, data, low, high):
        if low < high:
            mid = (low + high) // 2
            self.merge_sort(data, low, mid)
            self.merge_sort(data, mid + 1, high)
            self.merge(data, low, mid, high)

    def sort(self, data):
        print("歸併排序")
        return self.merge_sort(data, 0, len(data) - 1)


class Context:
    def __init__(self, data, strategy=None):
        self.data = data
        self.strategy = strategy

    def set_strategy(self, strategy):
        self.strategy = strategy

    def do_strategy(self):
        if self.strategy:
            self.strategy.sort(self.data)
        else:
            raise TypeError


li = list(range(100000))
random.shuffle(li)

context = Context(li, MergeSort())
context.do_strategy()
# print(context.data)

random.shuffle(context.data)

context.set_strategy(QuickSort())
context.do_strategy()