zero314

引言

以下是对 23 种设计模式的 Golang 实现添加详细注释，包括语法说明、设计模式的核心思想，以及代码的意图和上下文。代码保持简洁，注释涵盖模式的核心逻辑、Golang 特性和使用场景。为便于阅读，每种模式按原分类（创建型、结构型、行为型）组织，注释以行内和块注释形式添加，兼顾清晰与详尽。

创建型模式

1. 单例模式 (Singleton)

核心思想: 确保一个类只有一个实例，并提供全局访问点，适合需要统一资源管理的场景（如配置管理器）。

package singleton

import "sync"

// Singleton 定义单例结构体，包含所需数据
type Singleton struct {
    data string
}

// instance 存储全局唯一实例，包级私有变量防止外部直接访问
var instance *Singleton
// once 使用 sync.Once 保证初始化只执行一次，线程安全
var once sync.Once

// GetInstance 获取单例实例
// 使用 sync.Once 确保线程安全的懒汉式初始化
// 返回值 *Singleton 是指向单例的指针，保持一致性
func GetInstance() *Singleton {
    once.Do(func() {
        // 匿名函数中初始化单例，仅执行一次
        instance = &Singleton{data: "singleton instance"}
    })
    return instance
}

语法说明:

sync.Once: 标准库提供的同步原语，保证函数（如初始化）只执行一次，常用于单例或资源初始化。
var 声明包级变量，Golang 中包级变量默认零值（nil），适合存储单例实例。
懒汉式初始化延迟创建实例，优化启动性能。

注意: 单例在 Golang 并发环境中需谨慎，sync.Once是推荐方式，避免锁竞争。

2. 工厂方法模式 (Factory Method)

核心思想: 定义创建对象的接口，让子类决定实例化具体类，遵循开闭原则，支持扩展。

package factorymethod

// Product 定义产品接口，抽象出通用行为
type Product interface {
    Use() string // Use 方法表示产品功能
}

// ConcreteProductA 具体产品A，实现 Product 接口
type ConcreteProductA struct{}
func (p *ConcreteProductA) Use() string { return "Product A" }

// ConcreteProductB 具体产品B，实现 Product 接口
type ConcreteProductB struct{}
func (p *ConcreteProductB) Use() string { return "Product B" }

// Factory 定义工厂接口，声明创建产品的方法
type Factory interface {
    CreateProduct() Product
}

// ConcreteFactoryA 具体工厂A，负责创建 ConcreteProductA
type ConcreteFactoryA struct{}
func (f *ConcreteFactoryA) CreateProduct() Product { return &ConcreteProductA{} }

// ConcreteFactoryB 具体工厂B，负责创建 ConcreteProductB
type ConcreteFactoryB struct{}
func (f *ConcreteFactoryB) CreateProduct() Product { return &ConcreteProductB{} }

语法说明:

interface: Golang 接口定义行为契约，无需显式实现，隐式满足即可（如ConcreteProductA实现Product）。
结构体方法接收者使用指针（如*ConcreteProductA），适合需要修改状态或返回实例。
返回接口类型（Product）而非具体类型，增强灵活性和可扩展性。

模式优点: 解耦客户端与具体产品，新增产品只需新工厂和产品类，无需改动现有代码。

3. 抽象工厂模式 (Abstract Factory)

核心思想: 提供接口创建一组相关或依赖的对象家族，保证产品一致性（如 UI 组件套件）。

package abstractfactory

// Widget 定义窗口部件接口
type Widget interface {
    Render() string
}

// Button 定义按钮接口
type Button interface {
    Click() string
}

// WindowsButton Windows风格按钮
type WindowsButton struct{}
func (b *WindowsButton) Click() string { return "Windows Button Clicked" }

// WindowsWidget Windows风格窗口部件
type WindowsWidget struct{}
func (w *WindowsWidget) Render() string { return "Windows Widget Rendered" }

// MacButton Mac风格按钮
type MacButton struct{}
func (b *MacButton) Click() string { return "Mac Button Clicked" }

// MacWidget Mac风格窗口部件
type MacWidget struct{}
func (w *MacWidget) Render() string { return "Mac Widget Rendered" }

// GUIFactory 定义抽象工厂接口，创建一组相关产品
type GUIFactory interface {
    CreateButton() Button
    CreateWidget() Widget
}

// WindowsFactory Windows工厂，生产Windows风格产品
type WindowsFactory struct{}
func (f *WindowsFactory) CreateButton() Button { return &WindowsButton{} }
func (f *WindowsFactory) CreateWidget() Widget { return &WindowsWidget{} }

// MacFactory Mac工厂，生产Mac风格产品
type MacFactory struct{}
func (f *MacFactory) CreateButton() Button { return &MacButton{} }
func (f *MacFactory) CreateWidget() Widget { return &MacWidget{} }

语法说明:

多个接口（如Button、Widget）定义产品族，工厂接口统一创建方法。
结构体方法返回接口类型，支持多态，客户端无需关心具体实现。
Golang 无继承，组合和接口实现抽象工厂的灵活性。

模式优点: 确保产品家族一致（如 Windows 按钮配 Windows 窗口），易于切换产品族。

4. 建造者模式 (Builder)

核心思想: 将复杂对象的构建过程与其表示分离，支持分步构造和多种表示。

package builder

// House 表示最终产品，包含多个部分
type House struct {
    walls, doors, windows string
}

// HouseBuilder 定义建造者接口，声明构建步骤和获取产品方法
type HouseBuilder interface {
    BuildWalls() HouseBuilder   // 建造墙
    BuildDoors() HouseBuilder   // 建造门
    BuildWindows() HouseBuilder // 建造窗
    GetHouse() House           // 返回最终产品
}

// WoodenHouseBuilder 木屋建造者，实现具体构建逻辑
type WoodenHouseBuilder struct {
    house House // 存储构建中的产品
}

// BuildWalls 实现墙的构建，返回自身支持链式调用
func (b *WoodenHouseBuilder) BuildWalls() HouseBuilder {
    b.house.walls = "Wooden Walls"
    return b
}

// BuildDoors 实现门的构建
func (b *WoodenHouseBuilder) BuildDoors() HouseBuilder {
    b.house.doors = "Wooden Doors"
    return b
}

// BuildWindows 实现窗的构建
func (b *WoodenHouseBuilder) BuildWindows() HouseBuilder {
    b.house.windows = "Wooden Windows"
    return b
}

// GetHouse 返回最终构建的房子
func (b *WoodenHouseBuilder) GetHouse() House {
    return b.house
}

// Director 指挥者，控制构建流程
type Director struct {
    builder HouseBuilder
}

// Construct 执行标准构建流程，返回最终产品
func (d *Director) Construct() House {
    return d.builder.BuildWalls().BuildDoors().BuildWindows().GetHouse()
}

语法说明:

方法返回HouseBuilder接口，支持链式调用（如BuildWalls().BuildDoors()）。
Director解耦构建顺序与具体建造者，增强复用性。
结构体字段（如house）存储中间状态，Golang 无构造函数，初始化依赖方法。

模式优点: 分步构建复杂对象，支持不同建造者（如石屋、木屋）生成不同表示。

5. 原型模式 (Prototype)

核心思想: 通过复制现有对象创建新对象，适合复杂对象初始化成本高的场景。

package prototype

import (
    "bytes"
    "encoding/gob"
)

// Prototype 定义原型接口，声明克隆方法
type Prototype interface {
    Clone() Prototype
}

// ConcretePrototype 具体原型，包含需要复制的状态
type ConcretePrototype struct {
    name string
}

// Clone 实现深拷贝，通过序列化复制对象
// 使用 encoding/gob 序列化和反序列化实现通用深拷贝
func (p *ConcretePrototype) Clone() Prototype {
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf) // 创建编码器
    dec := gob.NewDecoder(&buf) // 创建解码器
    enc.Encode(p)               // 序列化当前对象
    var copy ConcretePrototype
    dec.Decode(&copy) // 反序列化生成新对象
    return &copy
}

语法说明:

encoding/gob: 标准库序列化工具，支持结构体深拷贝，适合复杂对象。
方法返回接口类型（Prototype），支持多态克隆。
bytes.Buffer作为序列化中间存储，高效且无外部依赖。

模式优点: 避免重复初始化，适合需要频繁创建相似对象的场景（如游戏中的物体模板）。

注意: gob序列化可能有性能开销，需根据场景权衡。

结构型模式

6. 适配器模式 (Adapter)

核心思想: 将不兼容的接口转换为客户端期望的接口，桥接新旧系统。

package adapter

// LegacyPrinter 旧系统，接口不兼容
type LegacyPrinter struct{}

// PrintLegacy 旧系统的打印方法
func (p *LegacyPrinter) PrintLegacy(s string) string {
    return "Legacy: " + s
}

// ModernPrinter 定义新系统期望的接口
type ModernPrinter interface {
    PrintModern(s string) string
}

// PrinterAdapter 适配器，将旧接口适配为新接口
type PrinterAdapter struct {
    legacy *LegacyPrinter // 组合旧系统对象
}

// PrintModern 实现新接口，调用旧系统的功能
func (a *PrinterAdapter) PrintModern(s string) string {
    return a.legacy.PrintLegacy(s)
}

语法说明:

结构体组合（legacy *LegacyPrinter）实现适配，Golang 无继承，组合更自然。
接口隐式实现，PrinterAdapter满足ModernPrinter无需显式声明。
方法转发调用旧系统逻辑，保持简单性。

模式优点: 复用现有代码，降低新旧系统迁移成本。

7. 桥接模式 (Bridge)

核心思想: 将抽象与实现分离，两者可独立变化，增强扩展性。

package bridge

// Renderer 定义实现层接口，负责具体渲染
type Renderer interface {
    Render(shape string) string
}

// VectorRenderer 矢量渲染实现
type VectorRenderer struct{}
func (r *VectorRenderer) Render(shape string) string { return "Vector " + shape }

// RasterRenderer 光栅渲染实现
type RasterRenderer struct{}
func (r *RasterRenderer) Render(shape string) string { return "Raster " + shape }

// Shape 定义抽象层接口
type Shape interface {
    Draw() string
}

// Circle 具体形状，组合渲染器
type Circle struct {
    renderer Renderer // 桥接点，连接抽象与实现
}

// Draw 调用渲染器的具体实现
func (c *Circle) Draw() string {
    return c.renderer.Render("Circle")
}

语法说明:

组合（renderer Renderer）实现桥接，抽象层（Circle）与实现层（Renderer）解耦。
接口定义行为契约，Renderer和Shape独立扩展。
方法转发（如Draw调用Render）实现功能分离。

模式优点: 支持抽象与实现独立扩展（如新增形状或渲染方式），符合开闭原则。

8. 组合模式 (Composite)

核心思想: 将对象组成树形结构，统一处理单个对象（叶子）和组合对象（容器）。

package composite

// Component 定义组件接口，统一叶子和容器行为
type Component interface {
    Operation() string
}

// Leaf 叶子节点，具体组件
type Leaf struct {
    name string
}

// Operation 叶子节点的具体操作
func (l *Leaf) Operation() string { return l.name }

// Composite 容器节点，可包含多个组件
type Composite struct {
    children []Component // 存储子节点
}

// Operation 容器节点的递归操作，聚合子节点结果
func (c *Composite) Operation() string {
    result := "Composite["
    for i, child := range c.children {
        if i > 0 {
            result += ","
        }
        result += child.Operation()
    }
    return result + "]"
}

// Add 添加子节点到容器
func (c *Composite) Add(child Component) {
    c.children = append(c.children, child)
}

语法说明:

接口（Component）统一叶子和容器行为，递归调用实现树形遍历。
切片（[]Component）存储子节点，Golang 动态数组支持灵活扩展。
字符串拼接展示树形结构，实际应用可替换为其他操作。

模式优点: 客户端统一操作叶子和容器，适合文件系统、UI 组件树等场景。

9. 装饰器模式 (Decorator)

核心思想: 动态为对象添加职责，扩展功能而不修改原有类。

package decorator

// Coffee 定义核心对象接口
type Coffee interface {
    Cost() float64
    Description() string
}

// SimpleCoffee 基础咖啡
type SimpleCoffee struct{}
func (c *SimpleCoffee) Cost() float64        { return 5.0 }
func (c *SimpleCoffee) Description() string  { return "Simple Coffee" }

// MilkDecorator 装饰器，为咖啡添加牛奶
type MilkDecorator struct {
    coffee Coffee // 组合被装饰对象
}

// Cost 在原有成本上增加牛奶费用
func (m *MilkDecorator) Cost() float64 { return m.coffee.Cost() + 1.0 }

// Description 在原有描述上追加牛奶信息
func (m *MilkDecorator) Description() string { return m.coffee.Description() + ", Milk" }

语法说明:

组合（coffee Coffee）实现装饰，动态扩展功能。
接口方法转发（如m.coffee.Cost()），保持原有行为。
Golang 无继承，装饰器通过接口和组合实现灵活性。

模式优点: 比继承更灵活，可动态组合多个装饰器（如加奶、加糖）。

10. 外观模式 (Facade)

核心思想: 为复杂子系统提供简化的统一接口，降低客户端使用成本。

package facade

// CPU 子系统组件
type CPU struct{}

// Start CPU启动逻辑
func (c *CPU) Start() string { return "CPU Started" }

// Memory 子系统组件
type Memory struct{}

// Load 内存加载逻辑
func (m *Memory) Load() string { return "Memory Loaded" }

// ComputerFacade 外观类，封装子系统操作
type ComputerFacade struct {
    cpu    CPU
    memory Memory
}

// Start 提供简化的启动接口，协调子系统
func (f *ComputerFacade) Start() string {
    return f.cpu.Start() + "; " + f.memory.Load()
}

语法说明:

结构体组合（cpu CPU、memory Memory）封装子系统。
方法（Start）聚合子系统操作，隐藏复杂性。
返回字符串模拟操作，实际可替换为具体逻辑。

模式优点: 简化客户端调用，隐藏子系统细节，适合复杂系统（如操作系统启动）。

11. 享元模式 (Flyweight)

核心思想: 通过共享不可变对象减少内存占用，适合大量相似对象。

package flyweight

// TreeType 享元，存储共享的内在状态
type TreeType struct {
    name, color string // 不可变属性
}

// TreeFactory 工厂，管理享元实例
type TreeFactory struct {
    treeTypes map[string]*TreeType // 缓存共享对象
}

// GetTreeType 获取或创建享元对象
// 使用 map 缓存，避免重复创建相同类型的树
func (f *TreeFactory) GetTreeType(name, color string) *TreeType {
    key := name + color
    if f.treeTypes == nil {
        f.treeTypes = make(map[string]*TreeType) // 延迟初始化 map
    }
    if t, ok := f.treeTypes[key]; ok {
        return t // 返回缓存的享元
    }
    t := &TreeType{name: name, color: color}
    f.treeTypes[key] = t // 缓存新享元
    return t
}

// Tree 具体对象，包含外在状态和享元
type Tree struct {
    x, y     int        // 外在状态，位置
    treeType *TreeType // 内在状态，共享
}

语法说明:

map存储共享对象，键为不可变属性组合，值是指针避免拷贝。
结构体分离内在（TreeType）和外在（x, y）状态。
延迟初始化（make）优化工厂启动。

模式优点: 大幅减少内存占用，适合大量重复对象（如游戏中的树、粒子）。

12. 代理模式 (Proxy)

核心思想: 为对象提供代理，控制访问、延迟加载或添加逻辑。

package proxy

// Image 定义目标接口
type Image interface {
    Display() string
}

// RealImage 真实对象，执行实际操作
type RealImage struct {
    filename string
}

// Display 真实对象的显示逻辑
func (r *RealImage) Display() string {
    return "Displaying " + r.filename
}

// ProxyImage 代理，控制对真实对象的访问
type ProxyImage struct {
    realImage *RealImage // 延迟加载的真实对象
    filename  string
}

// Display 代理的显示逻辑，延迟初始化真实对象
func (p *ProxyImage) Display() string {
    if p.realImage == nil {
        p.realImage = &RealImage{filename: p.filename} // 懒加载
    }
    return p.realImage.Display()
}

语法说明:

组合（realImage *RealImage）实现代理，延迟初始化节省资源。
接口（Image）统一代理和真实对象行为。
条件检查（nil）实现懒加载，优化性能。

模式优点: 控制访问（如延迟加载、权限检查），适合资源密集型对象（如大图）。

行为型模式

13. 责任链模式 (Chain of Responsibility)

核心思想: 将请求沿处理者链传递，直到被处理，解耦发送者和接收者。

package chainofresponsibility

// Handler 定义处理者接口
type Handler interface {
    HandleRequest(level int) string
    SetNext(handler Handler) // 设置下一个处理者
}

// ConcreteHandlerA 具体处理者A，处理级别1请求
type ConcreteHandlerA struct {
    next Handler // 指向链中下一个处理者
}

// HandleRequest 处理请求或传递给下一个处理者
func (h *ConcreteHandlerA) HandleRequest(level int) string {
    if level <= 1 {
        return "Handler A processed"
    }
    if h.next != nil {
        return h.next.HandleRequest(level)
    }
    return "No handler"
}

// SetNext 设置链中下一个处理者
func (h *ConcreteHandlerA) SetNext(handler Handler) {
    h.next = handler
}

// ConcreteHandlerB 具体处理者B，处理级别2请求
type ConcreteHandlerB struct {
    next Handler
}
func (h *ConcreteHandlerB) HandleRequest(level int) string {
    if level <= 2 {
        return "Handler B processed"
    }
    if h.next != nil {
        return h.next.HandleRequest(level)
    }
    return "No handler"
}
func (h *ConcreteHandlerB) SetNext(handler Handler) {
    h.next = handler
}

语法说明:

接口（Handler）定义链式行为，next字段实现动态链接。
条件逻辑（level <= 1）决定处理或传递。
方法转发（h.next.HandleRequest）实现链式调用。

模式优点: 动态调整处理链，适合日志处理、请求过滤等场景。

14. 命令模式 (Command)

核心思想: 将请求封装为对象，支持撤销、队列等操作，解耦调用者和执行者。

package command

// Command 定义命令接口
type Command interface {
    Execute() string
}

// Light 接收者，执行具体操作
type Light struct{}
func (l *Light) On() string  { return "Light On" }
func (l *Light) Off() string { return "Light Off" }

// LightOnCommand 具体命令，封装开灯操作
type LightOnCommand struct {
    light *Light // 绑定接收者
}

// Execute 执行开灯命令
func (c *LightOnCommand) Execute() string { return c.light.On() }

// RemoteControl 调用者，触发命令
type RemoteControl struct {
    command Command // 绑定命令对象
}

// PressButton 调用命令的执行
func (r *RemoteControl) PressButton() string {
    return r.command.Execute()
}

语法说明:

接口（Command）封装操作，Execute定义统一调用方式。
组合（light *Light）绑定接收者，命令对象隔离调用和执行。
方法（PressButton）触发命令，客户端无需知道细节。

模式优点: 支持撤销、宏命令等，适合 UI 控制、事务处理。

15. 迭代器模式 (Iterator)

核心思想: 提供顺序访问集合元素的方法，隐藏集合内部结构。

package iterator

// Iterator 定义迭代器接口
type Iterator interface {
    HasNext() bool
    Next() interface{}
}

// Collection 集合，存储元素
type Collection struct {
    items []interface{} // 存储任意类型元素
}

// ConcreteIterator 具体迭代器，遍历集合
type ConcreteIterator struct {
    collection *Collection // 绑定集合
    index      int         // 当前位置
}

// HasNext 检查是否还有元素
func (i *ConcreteIterator) HasNext() bool {
    return i.index < len(i.collection.items)
}

// Next 返回下一个元素并前进
func (i *ConcreteIterator) Next() interface{} {
    item := i.collection.items[i.index]
    i.index++
    return item
}

// CreateIterator 创建集合的迭代器
func (c *Collection) CreateIterator() Iterator {
    return &ConcreteIterator{collection: c}
}

语法说明:

接口（Iterator）定义遍历行为，interface{}支持任意类型。
结构体（ConcreteIterator）维护遍历状态，index记录位置。
方法（CreateIterator）返回迭代器，封装遍历逻辑。

模式优点: 隔离集合实现，适合复杂数据结构（如链表、树）。

16. 中介者模式 (Mediator)

核心思想: 通过中介者协调对象交互，降低耦合。

package mediator

// Mediator 定义中介者接口
type Mediator interface {
    Send(message string, sender Colleague)
}

// Colleague 定义交互对象接口
type Colleague interface {
    Send(message string)
    Receive(message string) string
}

// ConcreteMediator 具体中介者，管理交互
type ConcreteMediator struct {
    colleagues []Colleague // 存储交互对象
}

// Send 转发消息给其他对象
func (m *ConcreteMediator) Send(message string, sender Colleague) {
    for _, c := range m.colleagues {
        if c != sender {
            c.Receive(message)
        }
    }
}

// AddColleague 添加交互对象
func (m *ConcreteMediator) AddColleague(c Colleague) {
    m.colleagues = append(m.colleagues, c)
}

// ConcreteColleague 具体交互对象
type ConcreteColleague struct {
    mediator Mediator     // 绑定中介者
    messages []string     // 存储接收的消息
}

// Send 通过中介者发送消息
func (c *ConcreteColleague) Send(message string) {
    c.mediator.Send(message, c)
}

// Receive 接收消息
func (c *ConcreteColleague) Receive(message string) string {
    c.messages = append(c.messages, message)
    return "Received: " + message
}

语法说明:

接口（Mediator、Colleague）定义交互契约。
切片（colleagues）存储对象，动态管理交互者。
方法转发（Send调用Receive）实现集中协调。

模式优点: 降低对象间直接依赖，适合聊天系统、事件总线。

17. 备忘录模式 (Memento)

核心思想: 保存对象状态以便恢复，支持撤销操作。

package memento

// Memento 备忘录，存储状态
type Memento struct {
    state string // 不可变状态
}

// Originator 原对象，管理状态
type Originator struct {
    state string
}

// CreateMemento 创建备忘录
func (o *Originator) CreateMemento() *Memento {
    return &Memento{state: o.state}
}

// RestoreMemento 从备忘录恢复状态
func (o *Originator) RestoreMemento(m *Memento) {
    o.state = m.state
}

// Caretaker 管理者，存储备忘录
type Caretaker struct {
    mementos []*Memento // 支持多状态存储
}

// AddMemento 添加备忘录
func (c *Caretaker) AddMemento(m *Memento) {
    c.mementos = append(c.mementos, m)
}

语法说明:

结构体（Memento）封装状态，字段私有防止外部修改。
方法（CreateMemento、RestoreMemento）控制状态存取。
切片（mementos）支持多版本状态管理。

模式优点: 支持撤销、重做，适合编辑器、游戏存档。

18. 观察者模式 (Observer)

核心思想: 定义一对多依赖，状态变化时通知所有观察者。

package observer

// Subject 定义主题接口
type Subject interface {
    Register(observer Observer)
    NotifyAll()
}

// Observer 定义观察者接口
type Observer interface {
    Update(data string)
}

// ConcreteSubject 具体主题，管理观察者
type ConcreteSubject struct {
    observers []Observer // 存储观察者
    state     string    // 状态
}

// Register 添加观察者
func (s *ConcreteSubject) Register(observer Observer) {
    s.observers = append(s.observers, observer)
}

// NotifyAll 通知所有观察者
func (s *ConcreteSubject) NotifyAll() {
    for _, o := range s.observers {
        o.Update(s.state)
    }
}

// ConcreteObserver 具体观察者
type ConcreteObserver struct {
    id string
}

// Update 处理状态更新
func (o *ConcreteObserver) Update(data string) {
    // 实现更新逻辑
}

语法说明:

接口（Subject、Observer）定义发布-订阅关系。
切片（observers）动态管理观察者。
方法（NotifyAll）遍历通知，Golang 可结合goroutine优化并发通知。

模式优点: 解耦主题与观察者，适合事件驱动系统（如 UI 更新）。

19. 状态模式 (State)

核心思想: 根据对象状态改变行为，状态切换封装为对象。

package state

// State 定义状态接口
type State interface {
    Handle() string
}

// ConcreteStateA 具体状态A
type ConcreteStateA struct{}
func (s *ConcreteStateA) Handle() string { return "State A" }

// ConcreteStateB 具体状态B
type ConcreteStateB struct{}
func (s *ConcreteStateB) Handle() string { return "State B" }

// Context 上下文，管理状态
type Context struct {
    state State // 当前状态
}

// SetState 切换状态
func (c *Context) SetState(state State) {
    c.state = state
}

// Request 执行当前状态的行为
func (c *Context) Request() string {
    return c.state.Handle()
}

语法说明:

接口（State）定义状态行为，Context通过组合切换状态。
方法（SetState）动态更新状态，Request委托给当前状态。
Golang 接口支持多态，状态对象无需继承。

模式优点: 状态逻辑分离，适合复杂状态机（如订单流程）。

20. 策略模式 (Strategy)

核心思想: 定义算法家族，动态选择使用，解耦算法与客户端。

package strategy

// Strategy 定义策略接口
type Strategy interface {
    Execute(a, b int) int
}

// AddStrategy 加法策略
type AddStrategy struct{}
func (s *AddStrategy) Execute(a, b int) int { return a + b }

// SubtractStrategy 减法策略
type SubtractStrategy struct{}
func (s *SubtractStrategy) Execute(a, b int) int { return a - b }

// Context 上下文，选择策略
type Context struct {
    strategy Strategy // 当前策略
}

// SetStrategy 设置策略
func (c *Context) SetStrategy(strategy Strategy) {
    c.strategy = strategy
}

// ExecuteStrategy 执行当前策略
func (c *Context) ExecuteStrategy(a, b int) int {
    return c.strategy.Execute(a, b)
}

语法说明:

接口（Strategy）定义算法契约，Context通过组合选择算法。
方法（Execute）实现具体逻辑，SetStrategy动态切换。
Golang 无模板，接口实现策略的动态性。

模式优点: 算法可复用和替换，适合排序、支付方式选择等。

21. 模板方法模式 (Template Method)

核心思想: 定义算法骨架，子类实现具体步骤，固定流程。

package templatemethod

// Algorithm 定义模板接口
type Algorithm interface {
    Step1()
    Step2()
    TemplateMethod()
}

// ConcreteAlgorithm 具体算法，实现模板方法
type ConcreteAlgorithm struct{}

// Step1 步骤1，子类可自定义
func (a *ConcreteAlgorithm) Step1() { /* 实现步骤1 */ }

// Step2 步骤2，子类可自定义
func (a *ConcreteAlgorithm) Step2() { /* 实现步骤2 */ }

// TemplateMethod 定义算法骨架
func (a *ConcreteAlgorithm) TemplateMethod() {
    a.Step1()
    a.Step2()
}

语法说明:

接口（Algorithm）声明模板方法和步骤，Golang 无抽象类，接口模拟。
方法（TemplateMethod）固定流程，调用子类实现的步骤。
空实现（Step1、Step2）便于扩展。

模式优点: 复用算法结构，适合固定流程的场景（如数据处理管道）。

22. 访问者模式 (Visitor)

核心思想: 分离对象结构与操作，允许动态添加新操作。

package visitor

// Element 定义元素接口，接受访问者
type Element interface {
    Accept(visitor Visitor)
}

// ConcreteElementA 具体元素A
type ConcreteElementA struct{}

// Accept 接受访问者，调用对应操作
func (e *ConcreteElementA) Accept(visitor Visitor) {
    visitor.VisitA(e)
}

// ConcreteElementB 具体元素B
type ConcreteElementB struct{}
func (e *ConcreteElementB) Accept(visitor Visitor) {
    visitor.VisitB(e)
}

// Visitor 定义访问者接口
type Visitor interface {
    VisitA(e *ConcreteElementA)
    VisitB(e *ConcreteElementB)
}

// ConcreteVisitor 具体访问者，实现操作
type ConcreteVisitor struct{}
func (v *ConcreteVisitor) VisitA(e *ConcreteElementA) { /* 操作A */ }
func (v *ConcreteVisitor) VisitB(e *ConcreteElementB) { /* 操作B */ }

语法说明:

接口（Element、Visitor）定义双向交互，Accept触发访问。
方法（VisitA、VisitB）针对不同元素实现操作。
Golang 类型断言可优化访问者逻辑。

模式优点: 新增操作无需修改元素，适合稳定结构（如语法树）。

23. 解释器模式 (Interpreter)

核心思想: 为语言定义语法表示，解释执行，适合简单语言处理。

package interpreter

import "strings"

// Expression 定义表达式接口
type Expression interface {
    Interpret(context string) bool
}

// TerminalExpression 终结符表达式
type TerminalExpression struct {
    data string // 匹配的字符串
}

// Interpret 检查上下文是否包含data
func (e *TerminalExpression) Interpret(context string) bool {
    return strings.Contains(context, e.data)
}

// AndExpression 组合表达式，表示与逻辑
type AndExpression struct {
    expr1, expr2 Expression // 两个子表达式
}

// Interpret 检查两个子表达式是否都满足
func (e *AndExpression) Interpret(context string) bool {
    return e.expr1.Interpret(context) && e.expr2.Interpret(context)
}

语法说明:

接口（Expression）定义解释行为，递归组合实现复杂逻辑。
结构体（AndExpression）组合子表达式，模拟语法树。
strings.Contains简化匹配，实际可扩展为复杂解析。

模式优点: 适合 DSL、规则引擎，语法树支持复杂表达式。