观察者模式 (Observer)

• 核心概念：定义对象间一对多依赖关系
• Go实现：通道与回调函数
• 场景：事件通知、实时数据更新
• 代码示例：

type Subject struct {
    observers []Observer
    state     string
}

func (s *Subject) Attach(observer Observer) {
    s.observers = append(s.observers, observer)
}

func (s *Subject) SetState(state string) {
    s.state = state
    s.NotifyAll()
}

func (s *Subject) NotifyAll() {
    for _, observer := range s.observers {
        observer.Update(s.state)
    }
}

type Observer interface {
    Update(state string)
}

状态模式 (State)

• 核心概念：允许对象在内部状态改变时改变行为
• Go实现：状态接口
• 场景：工作流引擎、游戏角色状态
• 代码示例：

type State interface {
    Handle(context *Context)
}

type Context struct {
    state State
}

func (c *Context) Request() {
    c.state.Handle(c)
}

func (c *Context) SetState(state State) {
    c.state = state
}

type ConcreteStateA struct{}
func (s *ConcreteStateA) Handle(context *Context) {
    fmt.Println("State A handling")
    context.SetState(&ConcreteStateB{})
}

type ConcreteStateB struct{}
func (s *ConcreteStateB) Handle(context *Context) {
    fmt.Println("State B handling")
    context.SetState(&ConcreteStateA{})
}

策略模式 (Strategy)

• 核心概念：定义算法族，封装每个算法，使它们可互换
• Go实现：接口策略
• 场景：支付方式、排序算法
• 代码示例：

type PaymentStrategy interface {
    Pay(amount float64) string
}

type CreditCardStrategy struct{}
func (c *CreditCardStrategy) Pay(amount float64) string {
    return fmt.Sprintf("Paid %.2f using Credit Card", amount)
}

type PayPalStrategy struct{}
func (p *PayPalStrategy) Pay(amount float64) string {
    return fmt.Sprintf("Paid %.2f using PayPal", amount)
}

type PaymentContext struct {
    strategy PaymentStrategy
}

func (p *PaymentContext) ExecutePayment(amount float64) string {
    return p.strategy.Pay(amount)
}

模板方法模式 (Template Method)

• 核心概念：定义算法骨架，将步骤延迟到子类
• Go实现：嵌入结构体
• 场景：工作流、数据处理管道
• 代码示例：

type Game interface {
    Start()
    TakeTurn()
    HaveWinner() bool
    WinningPlayer() int
}

func PlayGame(g Game) {
    g.Start()
    for !g.HaveWinner() {
        g.TakeTurn()
    }
    fmt.Printf("Player %d wins\n", g.WinningPlayer())
}

type Chess struct {
    turn, maxTurns, currentPlayer int
}

func (c *Chess) Start() {
    fmt.Println("Starting chess game")
}

func (c *Chess) TakeTurn() {
    c.turn++
    fmt.Printf("Turn %d taken by player %d\n", c.turn, c.currentPlayer)
    c.currentPlayer = 1 - c.currentPlayer
}

func (c *Chess) HaveWinner() bool {
    return c.turn == c.maxTurns
}

func (c *Chess) WinningPlayer() int {
    return c.currentPlayer
}

访问者模式 (Visitor)

• 核心概念：在不改变元素类的前提下定义新操作
• Go实现：双重分派
• 场景：编译器AST遍历、文档处理
• 代码示例：

type Visitor interface {
    VisitForSquare(*Square)
    VisitForCircle(*Circle)
}

type Shape interface {
    Accept(visitor Visitor)
}

type Square struct {
    side float64
}

func (s *Square) Accept(v Visitor) {
    v.VisitForSquare(s)
}

type AreaCalculator struct {
    area float64
}

func (a *AreaCalculator) VisitForSquare(s *Square) {
    a.area = s.side * s.side
}

func (a *AreaCalculator) VisitForCircle(c *Circle) {
    a.area = math.Pi * c.radius * c.radius
}