文档章节

设计模式01策略模式

AllenOR灵感
 AllenOR灵感
发布于 2017/09/10 01:18
字数 2046
阅读 1
收藏 0

原始代码模型(全部采用继承)

代码
# -.- coding:utf-8 -.-
from __future__ import print_function


class Duck(object):

    def __init__(self, *args, **kwargs):
        self.name = '鸭子'
        self._ = '{}{}{}'

    def display(self):
        raise NotImplementedError

    def _display(self, value):
        value = self._.format(self.name, ': ', value)
        print(value)
        return value

    def quack(self):
        return self._display('呱呱叫')

    def swim(self):
        return self._display('游泳')


class MallardDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(MallardDuck, self).__init__(*args, **kwargs)
        self.name = '绿头鸭'

    def display(self):
         return self._display('外观是绿头')


class RedheadDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(RedheadDuck, self).__init__(*args, **kwargs)
        self.name = '红头鸭'

    def display(self):
        return self._display('外观是红头')


if __name__ == '__main__':
    mallard_duck = MallardDuck()
    mallard_duck.display()
    mallard_duck.quack()
    print()
    redhead_duck = RedheadDuck()
    redhead_duck.display()
    redhead_duck.quack()

# 显示结果
绿头鸭: 外观是绿头
绿头鸭: 呱呱叫

红头鸭: 外观是红头
红头鸭: 呱呱叫
需求

现在要求增加一个让鸭子飞的功能。(备注:需求要求很模糊)

解决办法

在Duck父类中增加一个fly方法,那么所有的子类都会拥有飞行行为(因为这就是继承)。

# -.- coding:utf-8 -.-
from __future__ import print_function


class Duck(object):

    # 在原来的基础上增加一个fly方法
    def fly(self):
        return self._display('飞行')



# 增加一个橡皮鸭对象
class RubberDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(RubberDuck, self).__init__(*args, **kwargs)
        self.name = '橡皮鸭'

    def display(self):
        return self._display('外观是橡皮')


if __name__ == '__main__':
    mallard_duck = MallardDuck()
    mallard_duck.display()
    mallard_duck.quack()
    mallard_duck.fly()
    print()
    redhead_duck = RedheadDuck()
    redhead_duck.display()
    redhead_duck.quack()
    redhead_duck.fly()
    print()
    redhead_duck = RubberDuck()
    redhead_duck.display()
    redhead_duck.quack()
    redhead_duck.fly()

# 显示结果
绿头鸭: 外观是绿头
绿头鸭: 呱呱叫
绿头鸭: 飞行

红头鸭: 外观是红头
红头鸭: 呱呱叫
红头鸭: 飞行

橡皮鸭: 外观是橡皮鸭
橡皮鸭: 呱呱叫
橡皮鸭: 飞行
延伸出来的问题

单从功能上来讲,在父类中增加了一个fly方法,那么所有的子类都拥有了fly行为,这是没问题的。但是从业务逻辑的角度来讲,那么并非所有鸭子都能飞(一般像被驯化的家鸭是没有飞行能力了,野鸭一般都能飞,故事中的橡皮鸭不能飞而且叫的声音也不一样,不是呱呱叫而是吱吱叫)。

另外一种尝试

采用继承中的一种特性<覆盖/或者叫多态>来让橡皮鸭自己实现自己的功能。

# -.- coding:utf-8 -.-
from __future__ import print_function


class Duck(object):

    def __init__(self, *args, **kwargs):
        self.name = '鸭子'
        self._ = '{}{}{}'

    def display(self):
        raise NotImplementedError

    def _display(self, value):
        value = self._.format(self.name, ': ', value)
        print(value)
        return value

    def fly(self):
        return self._display('飞行')

    def quack(self):
        return self._display('呱呱叫')

    def swim(self):
        return self._display('游泳')


class MallardDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(MallardDuck, self).__init__(*args, **kwargs)
        self.name = '绿头鸭'

    def display(self):
        return self._display('外观是绿头')


class RedheadDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(RedheadDuck, self).__init__(*args, **kwargs)
        self.name = '红头鸭'

    def display(self):
        return self._display('外观是红头')


class RubberDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(RubberDuck, self).__init__(*args, **kwargs)
        self.name = '橡皮鸭'

    # 覆盖Duck的quack方法
    def quack(self):
        return self._display('吱吱叫')

    # 覆盖Duck的fly方法
    def fly(self):
        return self._display('不能飞行')

    def display(self):
        return self._display('外观是橡皮')


# 增加诱饵鸭
class DecoyDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(DecoyDuck, self).__init__(*args, **kwargs)
        self.name = '诱饵鸭'

    # 覆盖Duck的quack方法
    def quack(self):
        return self._display('不能叫')

    # 覆盖Duck的fly方法
    def fly(self):
        return self._display('不能飞')

    def display(self):
        return self._display('外观是诱饵')


# 增加模型鸭
class ModelDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(ModelDuck, self).__init__(*args, **kwargs)
        self.name = '模型鸭'

    # 覆盖Duck的quack方法
    def quack(self):
        return self._display('不能叫')

    # 覆盖Duck的fly方法
    def fly(self):
        return self._display('不能飞')

    def display(self):
        return self._display('外观是模型')


if __name__ == '__main__':
    mallard_duck = MallardDuck()
    mallard_duck.display()
    mallard_duck.quack()
    mallard_duck.fly()
    print()
    redhead_duck = RedheadDuck()
    redhead_duck.display()
    redhead_duck.quack()
    redhead_duck.fly()
    print()
    rubber_duck = RubberDuck()
    rubber_duck.display()
    rubber_duck.quack()
    rubber_duck.fly()
    print()
    decoy_duck = DecoyDuck()
    decoy_duck.display()
    decoy_duck.quack()
    decoy_duck.fly()
    print()
    model_duck = ModelDuck()
    model_duck.display()
    model_duck.quack()
    model_duck.fly()

# 查看结果
绿头鸭: 外观是绿头
绿头鸭: 呱呱叫
绿头鸭: 飞行

红头鸭: 外观是红头
红头鸭: 呱呱叫
红头鸭: 飞行

橡皮鸭: 外观是橡皮
橡皮鸭: 吱吱叫
橡皮鸭: 不能飞行

诱饵鸭: 外观是诱饵
诱饵鸭: 不能叫
诱饵鸭: 不能飞

模型鸭: 外观是模型
模型鸭: 不能叫
模型鸭: 不能飞

组合+继承

嗯,上面这个尝试确实能解决橡皮鸭不能飞的问题(解决这个问题至少有三种办法:第一种是实现代码都完全在具体的方法中完成,这样就没办法做到代码的复用;第二种是在外部写好函数,相同功能要求的行为调用该函数,但是这种对代码的组织会存在一定的问题,随着项目的不断扩大而变得越来越不容易管理;第三种就是抽象成一个类将类似的实现进行一个合理的归纳。)。目前代码中是有五种鸭子,如果有200种鸭子,其中有15种跟橡皮鸭一样吱吱叫但是要能飞,另外40种跟橡皮鸭一样不能飞行但是要呱呱叫,这种情况该如何复用(每种鸭子类都跟橡皮鸭类一样自己去写一遍实现,我觉得这个坑太大了)?

像这种情况就是典型的行为分类,将<叫>和<飞>的行为剥离出来,然后根据不同的鸭子属性去给予它不同的能力(这种多重的能力在不同鸭子之间的搭配使用就叫做组合)。

代码
# -.- coding:utf-8 -.-
from __future__ import print_function


################################################################################
# Display                                                                      #
################################################################################
class Display(object):

    def __init__(self):
        self._ = '{}{}{}'

    def display(self, name, value):
        value = self._.format(name, ': ', value)
        print(value)
        return value

################################################################################
# Ducks                                                                        #
################################################################################
class Duck(object):

    _ = '{}{}{}'

    def __init__(self, *args, **kwargs):
        self.name = '鸭子'
        self.fly_behavior = None
        self.quack_behavior = None
        self._display = Display().display

    def display(self):
        raise NotImplementedError

    def fly(self):
        if self.fly_behavior:
            return self.fly_behavior.fly(self.name)
        return self._display(self.name, '飞行')

    def quack(self):
        if self.quack_behavior:
            return self.quack_behavior.quack(self.name)
        return self._display(self.name, '呱呱叫')

    def swim(self):
        return self._display(self.name, '游泳')

    def set_fly_behavior(self, fly_behavior):
        self.fly_behavior = fly_behavior

    def set_quack_behavior(self, quack_behavior):
        self.quack_behavior = quack_behavior


class MallardDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(MallardDuck, self).__init__(*args, **kwargs)
        self.name = '绿头鸭'

    def display(self):
        return self._display(self.name, '外观是绿头')


class RedheadDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(RedheadDuck, self).__init__(*args, **kwargs)
        self.name = '红头鸭'

    def display(self):
        return self._display(self.name, '外观是红头')


class RubberDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(RubberDuck, self).__init__(*args, **kwargs)
        self.name = '橡皮鸭'

    def quack(self):
        return self._display(self.name, '吱吱叫')

    def fly(self):
        return self._display(self.name, '不能飞行')

    def display(self):
        return self._display(self.name, '外观是橡皮')


class DecoyDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(DecoyDuck, self).__init__(*args, **kwargs)
        self.name = '诱饵鸭'

    def quack(self):
        return self._display(self.name, '不能叫')

    def fly(self):
        return self._display(self.name, '不能飞')

    def display(self):
        return self._display(self.name, '外观是诱饵')


class ModelDuck(Duck):

    def __init__(self, *args, **kwargs):
        super(ModelDuck, self).__init__(*args, **kwargs)
        self.name = '模型鸭'

    def quack(self):
        return self._display(self.name, '不能叫')

    def fly(self):
        return self._display(self.name, '不能飞')

    def display(self):
        return self._display(self.name, '外观是模型')


################################################################################
# Quack behaviors                                                              #
################################################################################
class QuackBehavior(object):

    def quack(self, *args, **kwargs):
        raise NotImplementedError


class Quack(QuackBehavior):

    def quack(self, name):
        return Display().display(name, "呱呱叫")


class MuteQuack(QuackBehavior):
    def quack(self, name):
        return Display().display(name, "不能叫")


class Squeak(QuackBehavior):
    def quack(self, name):
        return Display().display(name, "吱吱叫")


class FakeQuack(QuackBehavior):
    def quack(self, name):
        return Display().display(name, "假叫")


################################################################################
# Fly behaviors                                                                #
################################################################################
class FlyBehavior(object):
    def fly(self, *args, **kwargs):
        pass


class FlyWithWings(FlyBehavior):
    def fly(self, name):
        return Display().display(name, "飞行!")


class FlyNoWay(FlyBehavior):
    def fly(self, name):
        return Display().display(name, "不能飞!")


class FlyRocketPowered(FlyBehavior):
    def fly(self, name):
        return Display().display(name, "坐火箭飞!")


if __name__ == '__main__':
    mallard_duck = MallardDuck()
    mallard_duck.display()
    mallard_duck.quack()
    mallard_duck.fly()

    print()

    mallard_duck = MallardDuck()
    mallard_duck.display()
    mallard_duck.set_quack_behavior(FakeQuack())
    mallard_duck.set_fly_behavior(FlyRocketPowered())
    mallard_duck.quack()
    mallard_duck.fly()

# 显示结果
绿头鸭: 外观是绿头
绿头鸭: 呱呱叫
绿头鸭: 飞行

绿头鸭: 外观是绿头
绿头鸭: 假叫
绿头鸭: 坐火箭飞!
解决了什么问题

在最后__main__中可以看到,通过剥离出两个行为类之后,可以在运行时灵活通过给定不同类来影响它的最终结果。
这里面的一切都依赖于接口的一致性。

模式总结

策略模式强调的是将性质和行为相似的代码封装起来,让它们之间可以相互替换。

核心理念

在运行时选择操作(Choosing the operations at Runtime).

模式类型

行为模式

设计原则
  1. 找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。
  2. 针对接口编程,而不是针对实现编程。
  3. 多用组合,少用继承。

参考

本文转载自:http://www.jianshu.com/p/ecc0c24cfdb4

共有 人打赏支持
AllenOR灵感
粉丝 10
博文 2635
码字总数 83001
作品 0
程序员
编程中的那些套路——关于策略模式

该文章属于《编程中的那些经典套路——设计模式汇总》系列,并且以下内容基于语言PHP 今天讲讲策略模式,策略模式 和工厂模式十分相像(或者说在代码逻辑层面,他们是一样的)。 但策略模式与...

gzchen
08/27
0
0
php各种设计模式简单实践思考

前言 我一直觉得什么框架,版本,甚至语言对于一个coder来说真的不算什么,掌握一个特别高大上的一个框架或者是一个新的,少众的语言真的不算什么,因为你可以,我要花时间也可以,大家都是这...

michaelgbw
2016/06/13
0
0
javascript 设计模式之工厂(Factory)模式

工厂模式介绍 工厂模式是一个创建型的模式,主要就是创建对象。其中工厂模式又分为简单工厂模式和抽象工厂模式。简单工厂模式是通过工厂方法确定创建 对应类型的对象。抽象工厂模式是通过子类...

hlxiong
2014/04/14
0
0
JavaScript设计模式入坑

JavaScript设计模式入坑 介绍 设计模式编写易于维护的代码。 设计模式的开创者是一位土木工程师。Σ( ° △ °|||)︴,写代码就是盖房子。 模式 模式一种可以复用的解决方案。解决软件设计中...

小小小8021
10/18
0
0
java设计模式-- 单例模式

在很久之前,也就是在大二暑假的时候,那时候看马士兵的视频教程中有提到很多的设计模式。 java的设计模式大致可以分为3大类,23种设计模式。 其中,创建型模式有5种:单例模式、建造者模式、...

爱学习的逃课君
2014/11/27
0
0

没有更多内容

加载失败,请刷新页面

加载更多

HashTable

Hashtable 是一个散列表,它存储的内容是键值对(key-value)映射 Hashtable 继承于Dictionary,实现了Map、Cloneable、java.io.Serializable接口 Hashtable 的函数都是同步的,这意味着它是线...

职业搬砖20年
17分钟前
1
0
Linux系统状态查看命令1

10月23日任务 10.1 使用w查看系统负载 10.2 vmstat命令 10.3 top命令 10.4 sar命令 10.5 nload命令 查看系统负载 w命令 # 第一行:当前系统时间,系统启动时间,登录的用户,系统负载:1分钟...

robertt15
32分钟前
1
0
缓存那些事

前言 一般而言,现在互联网应用(网站或App)的整体流程,可以概括如图1所示,用户请求从界面(浏览器或App界面)到网络转发、应用服务再到存储(数据库或文件系统),然后返回到界面呈现内容...

Skqing
41分钟前
2
0
nginx开启stub_status模块配置方法

nginx开启stub_status模块配置方法 2017年12月13日 15:57:29 ly_dengle 阅读数:3765 标签: stub_statusnginxnginx开启stub_status模块 更多 个人分类: 软件工具php 版权声明:本文为博主原...

linjin200
48分钟前
3
0
挑逗 Java 程序员的那些 Scala 绝技

有个问题一直困扰着 Scala 社区,为什么一些 Java 开发者将 Scala 捧到了天上,认为它是来自上帝之吻的完美语言;而另外一些 Java 开发者却对它望而却步,认为它过于复杂而难以理解。同样是 ...

joymufeng
51分钟前
134
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部