结构型:在对象外面「套一层」

// 调用方期望的接口 A —— 系统里到处都按这个签名调
interface PaymentGateway:
    charge(amountInCents): Receipt

// 第三方库只给了接口 B,方法名、参数、单位都不一样,且改不了
class StripeSDK:
    createCharge(dollars: float, currency: string): StripeResponse

// 适配器:对外实现 A,内部持有 B,逐方法翻译
class StripeAdapter implements PaymentGateway:
    sdk: StripeSDK
    constructor(sdk): this.sdk = sdk
    charge(amountInCents):
        dollars = amountInCents / 100            // 翻译:分 → 美元
        resp = this.sdk.createCharge(dollars, "USD")
        return new Receipt(resp.id, resp.paidAmount)   // 翻译:B 的响应 → A 的 Receipt

// 调用方完全不知道背后是 Stripe,只认 PaymentGateway
gateway: PaymentGateway = new StripeAdapter(new StripeSDK())
gateway.charge(2999)                              // 按期望接口 A 调

// 被包对象与所有装饰器共享的同一个接口
interface DataSource:
    write(data): void
    read(): bytes

// 原始对象:朴素地写文件
class FileSource implements DataSource:
    write(data): ...把 data 写入文件
    read(): ...从文件读出

// 装饰器基类:实现同一接口,且【持有】一个同接口对象
abstract class SourceDecorator implements DataSource:
    wrappee: DataSource                       // ← 可能是原对象,也可能是另一个装饰器
    constructor(source): this.wrappee = source

class EncryptionDecorator extends SourceDecorator:
    write(data): this.wrappee.write(encrypt(data))    // 先加密,再委托内层
    read():       return decrypt(this.wrappee.read())

class CompressionDecorator extends SourceDecorator:
    write(data): this.wrappee.write(compress(data))
    read():       return decompress(this.wrappee.read())

// ④ 由【客户端】决定叠哪几层、什么顺序
source: DataSource = new EncryptionDecorator(
                         new CompressionDecorator(
                             new FileSource()))       // 写时:先压缩 → 再加密 → 落盘
source.write(payload)                                 // 调用方只看到 DataSource 接口

// 代理与真实对象共享的同一个接口
interface Image:
    display(): void

// 真实对象:构造代价很大(立刻从磁盘加载几百兆)
class RealImage implements Image:
    constructor(path):
        this.data = loadFromDisk(path)         // 重操作,发生在构造时
    display(): render(this.data)

// 代理:同一个接口;真实对象由【代理自己】按需创建
class ImageProxy implements Image:
    path: string
    real: RealImage = null                     // 一开始并不存在
    constructor(path): this.path = path        // 只记住路径,不加载
    display():
        if this.real == null:
            this.real = new RealImage(this.path)   // ← 代理自己决定何时创建真身
        this.real.display()                        // 转交调用,不加新业务

// 客户端把它当普通 Image 用;构造时不加载,首次 display 才真正读盘
img: Image = new ImageProxy("huge.png")        // 瞬间返回,未读盘
img.display()                                  // 此刻才加载并渲染

// 子系统:多个部件,各管一段,直接用要懂调用顺序与依赖
class VideoFile: ...
class CodecFactory:   extract(file): Codec
class BitrateReader:  read(file, codec): bytes; convert(buffer, codec): bytes
class AudioMixer:     fix(result): bytes

// 外观:把"转码一个视频"这套繁琐流程,收成一个方法
class VideoConverter:
    convert(filename, targetFormat): File
        file   = new VideoFile(filename)
        codec  = CodecFactory.extract(file)         // ① 取编解码器
        buffer = BitrateReader.read(file, codec)    // ② 读码率
        result = BitrateReader.convert(buffer, codec)  // ③ 转换
        result = AudioMixer.fix(result)             // ④ 修音轨
        return new File(result)

// 调用方一句话用完;不必懂上面四步,也不必懂部件间依赖
converter = new VideoConverter()
mp4 = converter.convert("birthday.ogg", "mp4")
// 仍可绕过外观,直接 new BitrateReader() 做高级操作 —— 外观不封锁子系统

// 维度二:实现体系(渲染后端)—— 独立演化
interface Renderer:
    drawCircle(x, y, r): void

class VectorRenderer implements Renderer:
    drawCircle(x, y, r): ...画成矢量
class RasterRenderer implements Renderer:
    drawCircle(x, y, r): ...画成像素

// 维度一:抽象体系(形状)—— 通过【桥】持有一个 Renderer
abstract class Shape:
    renderer: Renderer                        // ← 这就是"桥":抽象持有实现
    constructor(renderer): this.renderer = renderer
    abstract draw(): void

class Circle extends Shape:
    x, y, radius
    draw(): this.renderer.drawCircle(this.x, this.y, this.radius)  // 委托给实现维度

// 两个维度自由组合;加一种后端只需新增 1 个 Renderer,不动任何 Shape
c1 = new Circle(new VectorRenderer())   // 矢量圆
c2 = new Circle(new RasterRenderer())   // 光栅圆 —— 同一个 Circle,换实现即可

// 叶子与容器共享的同一个接口
interface Node:
    size(): number
    // add/remove 也常被放进这个共享接口 —— 对叶子无意义,这是有意的权衡

// 叶子:没有孩子
class FileNode implements Node:
    bytes: number
    size(): return this.bytes
    // add(child): 对文件无意义 —— 抛异常或空实现

// 容器:持有 N 个孩子,聚合它们的结果
class FolderNode implements Node:
    children: Node[] = []
    add(child): this.children.push(child)        // 容器才有意义
    size():
        total = 0
        for child in this.children:              // 遍历 N 个孩子
            total += child.size()                // 递归:孩子可能又是容器
        return total                             // 聚合 N 个结果

// 客户端对任何节点都调同一个 size(),不问它是文件还是文件夹
root = new FolderNode()
root.add(new FileNode(100))
sub = new FolderNode(); sub.add(new FileNode(50)); root.add(sub)
print(root.size())                               // 150 —— 递归自动下穿