设计模式——策略模式

一、策略模式

定义了算法族，分别封装起来，让它们之间可以相互替换。让算法的变化独立于算法的使用者。

package main

import "fmt"

type Quack interface {
	quack()
}

type Fly interface{
	fly()
}

type Duck struct{
	Quack
	Fly
}

//两种叫的方法
type ZiziQuack struct{
}
func (zz ZiziQuack) quack(){
	fmt.Println("ZiZi…")
}
type GuaGuaQuack struct{
}
func (gg GuaGuaQuack) quack(){
	fmt.Println("GuaGua…")
}
//两种飞的方法
type WingFly struct{
}
func (wf WingFly) fly(){
	fmt.Println("Fly fly fly…")
}
type NoFly struct{
}
func (nf NoFly) fly(){
	fmt.Println("Not fly")
}

//所有鸭子都可以游泳
func (*Duck) swim(){
	fmt.Println("All the duck can swim!")
} 
func (dk *Duck) SetQuack(qk Quack){
	dk.Quack = qk
}
func (dk *Duck) SetFly(f Fly){
	dk.Fly = f
}

//真鸭子
type RealDuck struct{
	Duck
}
func NewRealDuck() *RealDuck{
	rd := &RealDuck{}
	rd.Quack = GuaGuaQuack{}
	rd.Fly   = WingFly{}
	return rd
}
//假鸭子
type FakeDuck struct{
	Duck
}
func NewFakeDuck() *FakeDuck{
	fd := &FakeDuck{}
	fd.Quack = ZiziQuack{}
	fd.Fly   = NoFly{}
	return fd
}

func main () {
	rd := NewRealDuck()
	fd := NewFakeDuck()
	rd.quack()
	rd.fly()
	rd.swim()
	fd.quack()
	fd.fly()
	fd.swim()
	zq := ZiziQuack{}
	rd.SetQuack(zq)
	rd.quack()
}