设计模式(策略模式)

本人花费半年的时间总结的《Java面试指南》已拿腾讯等大厂offer,已开源在github ,欢迎star!

转载声明:转载请注明出处,本技术博客是本人原创文章

本文GitHub https://github.com/OUYANGSIHAI/JavaInterview 已收录,这是我花了6个月总结的一线大厂Java面试总结,本人已拿大厂offer,欢迎star

原文链接:blog.ouyangsihai.cn >> 设计模式(策略模式)

点击上方”python宝典”,关注获取python全套视频,

技术文章第一时间送达!

策略模式

1、内容

定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

2、角色

  • 抽象策略(Strategy)
  • 具体策略(ConcreteStrategy)
  • 上下文(Context)
  • 3、使用场景

  • 许多相关的类仅仅是行为有异
  • 需要使用一个算法的不同变体
  • 算法使用了客户端无需知道的数据
  • 一个类中的多种行为以多个条件语句的形式存在,可以将这些行为封装如不同的策略类中
  • 4、优点  

  • 定义了一系列可重用的算法和行为
  •  消除了一些条件语句
  •  可以提供相同行为的不同实现
  • **5、缺点**
  • 客户必须了解不同的策略
  •  策略与上下文之间的通信开销
  • 增加了对象的数目
  • 6、代码示例

    
    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()
    
    设计模式(策略模式)

    识别图中二维码,欢迎关注python宝典

    本人花费半年的时间总结的《Java面试指南》已拿腾讯等大厂offer,已开源在github ,欢迎star!

    转载声明:转载请注明出处,本技术博客是本人原创文章

    本文GitHub https://github.com/OUYANGSIHAI/JavaInterview 已收录,这是我花了6个月总结的一线大厂Java面试总结,本人已拿大厂offer,欢迎star

    原文链接:blog.ouyangsihai.cn >> 设计模式(策略模式)


     上一篇
    设计模式(责任链模式) 设计模式(责任链模式)
    点击上方”python宝典”,关注获取python全套视频, 技术文章第一时间送达! 责任链模式1、内容 使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求 直到有一个对象处
    2021-04-05
    下一篇 
    设计模式(原型模式) 设计模式(原型模式)
    点击上方”python宝典”,关注获取python全套视频, 技术文章第一时间送达! 原型模式以前听过这样一句话:“程序员的最高境界就是Ctrl+C、Ctrl+V”,我们先不论这句话的对错,就论这个过程,这个过程我们都知道无非就是复制一个对
    2021-04-05