一、策略模式
定义了算法族,分别封装起来,让它们之间可以相互替换。让算法的变化独立于算法的使用者。
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()
}