策略模式：抛砖引玉，为了让一些小白理解设计模式而写，大神请绕行。顺便可以熟悉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）。这种方式和“继承”的不同在于，鸭子的行为不是从基类继承来的，而是通过适当的行为对象组合而来。
这是一个很重要的技巧。
多用组合，少用继承。
你可以讲一种行为的多种实现合并成一个行为组合，相关对象通过引用这个组合的某种实现来组合而成。
好了，这就是一个简单的策略模式。
