设计模式——Go语言（Golang）版：20

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图：