地基:为什么所有模式都在做同一件事

function priceOf(order):
    total = sum(order.items)
    if order.customer.isVip:
        total = total * 0.85          // VIP 85 折
    return total

function priceOf(order):
    total = sum(order.items)
    if order.customer.isVip:
        total = total * 0.85
    else if order.coupon == "SUMMER":
        total = total - 20
    else if order.isFirstOrder:
        total = total * 0.9
    // …下一个规则继续往这条链上加
    return total

// ① 把"会变的折扣算法"抽成一个稳定接口(机制一:面向接口)
interface DiscountStrategy:
    apply(total): number

// ② 每条折扣规则 = 一个独立的策略对象,互不知晓彼此
class VipDiscount implements DiscountStrategy:
    apply(total): return total * 0.85

class SummerCoupon implements DiscountStrategy:
    apply(total): return total - 20

class NoDiscount implements DiscountStrategy:
    apply(total): return total

// ③ 不变的计费骨架(Context),持有一个策略,委托给它(机制二:组合)
class Checkout:
    strategy: DiscountStrategy
    constructor(strategy): this.strategy = strategy
    price(order):
        total = sum(order.items)
        return this.strategy.apply(total)     // 骨架不知道是哪种折扣

// ④ 由客户端挑选用哪个策略
checkout = new Checkout(new VipDiscount())
print(checkout.price(order))                  // 按 VIP 折扣算

// 接口 + 一族实现 + Context 持有它 —— 和策略一模一样的骨架
interface OrderState:
    next(order): OrderState           // 注意返回值:下一个状态

class PendingState implements OrderState:
    next(order): return new PaidState()      // 状态自己决定转移到谁

class PaidState implements OrderState:
    next(order): return new ShippedState()

class Order:
    state: OrderState
    advance(): this.state = this.state.next(this)   // 委托给当前状态

abstract class ReportBuilder:
    // 骨架定死顺序,这个方法子类不许改
    build():
        header()
        body()        // ← 钩子,子类填
        footer()
    header(): print("=== 报表 ===")
    abstract body()   // 留给子类
    footer(): print("=== 完 ===")

class SalesReport extends ReportBuilder:
    body(): print("本月销售额 …")