1、策略模式 Strategy Pattern

策略模式：抛砖引玉，为了让一些小白理解设计模式而写，大神请绕行。顺便可以熟悉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 
```go
//唐老鸭
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 
```go
//绿头鸭
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）。这种方式和“继承”的不同在于，鸭子的行为不是从基类继承来的，而是通过适当的行为对象组合而来。
这是一个很重要的技巧。

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