1、策略模式 Strategy Pattern

teddrummer · · 973 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

策略模式:抛砖引玉,为了让一些小白理解设计模式而写,大神请绕行。顺便可以熟悉GoLang

经典鸭子问题:
鸭子有个基础的父类,但是有很多种鸭子,比如:模型鸭、唐老鸭、绿头鸭
鸭子属性这里就忽略了,直接用两个行为来举例子:叫和飞
从这3种鸭子来看:
绿头鸭会呱呱叫,模型鸭不会叫,唐老鸭会说话(就算是会说话吧)
绿头鸭会飞,模型鸭和唐老鸭都不会飞
好了,我们现在需要做的就是实现一个鸭子的父类,让后让模型鸭、唐老鸭、绿头鸭都继承这个父类。
定义飞和叫两个行为接口,每种鸭子继承父类并实现飞和叫两个行为。

找出应用中核能需要变化之处,把它们独立起来,不要和那些不需要变化的代码混在一起。

好的,继续,下面我们先来说下飞
根据我们要实现的3种模型,我们需要实现两个飞的行为,一个是会飞一个是不会飞
首先我们用接口来封装一个飞的接口来并实现飞的行为

针对接口编程,而不是针对实现编程。

type flyBehavior interface {
    Fly()
}

然后在分别定义两个结构体来实现会飞和不会飞

//会飞
type flyWithWings struct {}
func (f flyWithWings) Fly()  {
    fmt.Println("我能飞")
}

//不会飞
type flyNoWay struct {}
func (f flyNoWay) Fly()  {
    fmt.Println("我不能飞")
}

接下来,我么用同样的方式来封装一个叫的接口并实现叫的行为

type quackBehavior interface {
    Quack()
}

然后这里需要定义三个结构体来实现呱呱叫、不会叫和会说话

//呱呱叫
type quack struct {}
func (q quack) Quack()  {
    fmt.Println("呱呱呱")
}

//哑巴
type muteQuack struct {}
func (q muteQuack) Quack()  {
    fmt.Println("………………")
}

//说话
type squeak struct {}
func (q squeak) Quack()  {
    fmt.Println("我说话啦")
}

最后就剩鸭子类和三个不同的鸭子了
先定义一个鸭子基类,这里我加了个基类的自我介绍方法,后面三个鸭子各自重写基类的自我介绍。
鸭子基类定义了飞和叫着两个行为接口

//鸭子基类
type duck struct {
    FlyBehavior flyBehavior
    QuackBehavior quackBehavior
}
func (this duck) Introduce() {
    fmt.Println("来个自我介绍")
}

模型鸭,通过flyNoWay来实现FlyBehavior ,通过muteQuack来实现QuackBehavior

//模型鸭
type ModelDuck struct {
    duck
}
func (this *ModelDuck) Introduce() {
    fmt.Println("我是模型鸭")
}
func (this *ModelDuck) New() {
    this.FlyBehavior = new(flyNoWay)
    this.QuackBehavior = new(muteQuack)
}
···
唐老鸭,通过flyNoWay来实现FlyBehavior ,通过squeak来实现QuackBehavior 

//唐老鸭
type DdfdDuck struct {
duck
}
func (this *DdfdDuck) Introduce() {
fmt.Println("我是唐老鸭")
}
func (this *DdfdDuck)New() {
this.FlyBehavior = new(flyNoWay)
this.QuackBehavior = new(squeak)
}
···
绿头鸭,通过flyWithWings来实现FlyBehavior ,通过quack来实现QuackBehavior

//绿头鸭
type MallardDuck struct {
    duck
}
func (this *MallardDuck) Introduce() {
    fmt.Println("我是绿头鸭")
}
func (this *MallardDuck)New() {
    this.FlyBehavior = new(flyWithWings)
    this.QuackBehavior = new(quack)
}

好了,现在我们的准备工作已经完成了,主函数来试试看

func main() {
    modelDuck := new(strategyPattern.ModelDuck)
    modelDuck.New()
    modelDuck.Introduce()
    modelDuck.FlyBehavior.Fly()
    modelDuck.QuackBehavior.Quack()

    ddfdDuck := new(strategyPattern.DdfdDuck)
    ddfdDuck.New()
    ddfdDuck.Introduce()
    ddfdDuck.FlyBehavior.Fly()
    ddfdDuck.QuackBehavior.Quack()

    mallardDuck := new(strategyPattern.MallardDuck)
    mallardDuck.New()
    mallardDuck.Introduce()
    mallardDuck.FlyBehavior.Fly()
    mallardDuck.QuackBehavior.Quack()
}

运行打印的结果:

我是模型鸭
我不能飞
………………
我是唐老鸭
我不能飞
我说话啦
我是绿头鸭
我能飞
呱呱呱

每一个鸭子都有一个FlyBehavior和QuackBehavior ,好讲飞和叫委托给他们处理。
当你每个鸭子通过这两个类结合使用,这就可以称之为组合(composition)。这种方式和“继承”的不同在于,鸭子的行为不是从基类继承来的,而是通过适当的行为对象组合而来。
这是一个很重要的技巧。

多用组合,少用继承。
你可以讲一种行为的多种实现合并成一个行为组合,相关对象通过引用这个组合的某种实现来组合而成。
好了,这就是一个简单的策略模式。


有疑问加站长微信联系(非本文作者)

本文来自:简书

感谢作者:teddrummer

查看原文:1、策略模式 Strategy Pattern

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:701969077

973 次点击  ∙  1 赞  
加入收藏 微博
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传