1、介绍

定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

策略模式:Strategy,是指,定义一组算法,并把其封装到一个对象中。然后在运行时,可以灵活的使用其中的一个算法。

策略模式的结构

封装类:也叫上下文,对策略进行二次封装,目的是避免高层模块对策略的直接调用。
抽象策略:通常情况下为一个接口,当各个实现类中存在着重复的逻辑时,则使用抽象类来封装这部分公共的代码,此时,策略模式看上去更像是模版方法模式。
具体策略:具体策略角色通常由一组封装了算法的类来担任,这些类之间可以根据需要自由替换。

2、示例

示例代码:

package main

import "fmt"

//支付环境
type PaymentContext struct {
	Name ,CardId string
	Money int
}
//支付策略
type PaymentStrategy interface {
	Pay(ctx *PaymentContext)
}
//支付
type Payment struct {
	Context *PaymentContext
	Strategy PaymentStrategy
}

func NewPayment(name,cardId string,money int,strategy PaymentStrategy) *Payment {
  return &Payment{
	  Context:  &PaymentContext{
		  Name:   name,
		  CardId: cardId,
		  Money:  money,
	  },
	  Strategy: strategy,
  }
}
func (p *Payment)Pay() {
	//Strategy是接口类型(PaymentStrategy),那个对象(该对象必须实现该接口)调用,就运行那个对象的方法
	p.Strategy.Pay(p.Context)
}
//付款
type Cash struct{}
func (*Cash)Pay(ctx *PaymentContext)  {
	fmt.Printf("支付 %v¥ 到 %v\n",ctx.Money,ctx.Name)
}
//银行
type Bank struct{}

func (*Bank)Pay(ctx *PaymentContext) {
	fmt.Printf("支付 %v¥ 到 %v(银行账号为:%v)",ctx.Money,ctx.Name,ctx.CardId)
}
func main()  {
	cash :=&Cash{}
	payment := NewPayment("张三","10086",666,cash) //最后一个参数为接口类型,因此可以传递实现接口的对象(结构体)
	payment.Pay()

	bank:=&Bank{}
	payment=NewPayment("张三","10086",666,bank)
	payment.Pay()
}

UML图: