数据结构-结构型模式

结构型模式

特点：关注类和对象的组合

策略模式

定义一组算法，将每个算法都封装起来，并且使它们之间可以互换

非策略模式

将所有操作封装在同一个函数中，通过if … else … 的形式来调用不同的计算方法，这种方式称为硬编码。

if oprater == "+" {
} else if oprator == "*" {
} 

缺点：我们需要经常添加和修改策略，使得代码越来越难维护

why : 使用策略模式来解耦。

how：定义一些类来封装不同的算法，每一个类封装一个具体的算法（即策略）

核心思想： 通过 抽象出来一个策略接口， 让 各种策略实现这个接口 达到 策略的扩展 及多态。 实现 策略和 do 函数的解耦

example：

package strategy
// 策略模式
// 定义一个策略类
type IStrategy interface {
    do (int , int) int
}
// 策略实现：减
type reduce struct{    
}
func (*reduce) do(a, b int) int {
    return a - b
}
// 策略实现：加
type add struct{   
}
func (*add) do(a, b int) int {
    return a + b
}
// 具体策略的执行者
type Operator struct {
    strategy IStrategy
}
// 设置策略
func (operator *Operator) setStrategy(strategy IStratgy) {
	operator.strategy = strategy
}    
// 调用策略中的方法
func (operator *Operator) calculate(a, b int) int {
    return operator.strategy.do(a, b)
}

1、定义了策略接口；定义了add 和 reduce 两种策略；定义了一个策略执行者
可以看到，我们可以随意更换策略，而不影响 Operator 的所有实现。
Operator 看到是接口   抽象。  


func TestStrategy(t *testing.T) {
    operator := Opetator{}
    operator.setStrategy(&add{}) 
    result := operator.calculate(1, 2)
}

模板模式

模版模式 (Template Pattern) 定义一个操作中算法的骨架，而将一些步骤延迟到子类中。这种方法让子类在不改变一个算法结构的情况下，就能重新定义该算法的某些特定步骤。

模板模式就是

将一个类中能够公共使用的方法放置在抽象类中实现，

将不能公共使用的方法作为抽象方法，强制子类去实现，

这样就做到了将一个类作为一个模板，让开发者去填充需要填充的地方。

package template
import "fmt"
type Cooker interface {
    fire()
    cooke()
    outfire()
}
// 类似一个抽象类
type CookMenu struct {}
func (CookMenu) fire() {
    fmt.Println("开火")
}
// 做菜，交给具体的子类实现
func (CookMenu) cooke() {}
func (CookMenu) outfire() {
    fmt.Println("关火")
}
// 封装具体步骤
func doCook(cook Cooker) {
    cook.fire()
    cook.cooke()
    cook.outfire()
}
type XiHongShi struct {
    CookMenu
}
func (*XiHongShi) cooke() {
    fmt.Println("做西红柿")
}
type ChaoJiDan struct {  
    CookMenu
}
func (ChaoJiDan) cooke() {
    fmt.Println("做炒鸡蛋")
}

func TestTemplate(t *testing.T) {
    // 做西红柿
    xihongshi := &xihongshi{}
    doCook(xihongshi)
}