Go语言实现桥接模式

package main

import "fmt"

// Implementor 定义了实现部分的接口，具体实现由其子类提供
type DrawingSurface interface {
    Draw(x, y int)
}

// ConcreteImplementor 实现了Implementor接口，并提供了具体的实现逻辑
type Paper struct{}

func (p *Paper) Draw(x, y int) {
    fmt.Printf("Drawing on paper at (%d, %d)\n", x, y)
}

type Screen struct{}

func (s *Screen) Draw(x, y int) {
    fmt.Printf("Drawing on screen at (%d, %d)\n", x, y)
}

// Abstraction 定义了抽象部分的接口，并持有一个对Implementor类型的引用
type Tool interface {
    SetDrawingSurface(surface DrawingSurface)
    DrawTool(x, y int)
}

type BaseTool struct {
    surface DrawingSurface
}

func (bt *BaseTool) SetDrawingSurface(surface DrawingSurface) {
    bt.surface = surface
}

func (bt *BaseTool) DrawTool(x, y int) {
    if bt.surface != nil {
        bt.surface.Draw(x, y)
    }
}

// RefinedAbstraction 扩展了Abstraction，并提供了更具体的实现细节
type Pen struct {
    BaseTool
}

func NewPen() *Pen {
    return &Pen{}
}

func (p *Pen) DrawTool(x, y int) {
    fmt.Println("Using pen to draw")
    p.BaseTool.DrawTool(x, y)
}

type Eraser struct {
    BaseTool
}

func NewEraser() *Eraser {
    return &Eraser{}
}

func (e *Eraser) DrawTool(x, y int) {
    fmt.Println("Using eraser to draw")
    e.BaseTool.DrawTool(x, y)
}

func clientCode(tool Tool, surface DrawingSurface, x, y int) {
    tool.SetDrawingSurface(surface)
    tool.DrawTool(x, y)
}

func main() {
    // 使用桥接模式组合Pen和Paper
    pen := NewPen()
    paper := &Paper{}
    clientCode(pen, paper, 10, 20)

    // 使用桥接模式组合Eraser和Screen
    eraser := NewEraser()
    screen := &Screen{}
    clientCode(eraser, screen, 30, 40)
}