罗罗编程学习记录
本页内容 展开查看

01.3.2.13 多语言实现对照与选型

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解

覆盖范围

  • 七语言 × 常用模式族的落地矩阵总览
  • 一等函数、闭包、接口、enum、模块系统对模式的替代关系
  • Go 的「少模式」哲学与接口最小化
  • Rust 所有权与借用规则如何改变结构型模式
  • TypeScript 结构类型对模式表达的影响
  • Python 鸭子类型下模式的退化与惯用写法
  • PHP 的 trait 与复用方式对模式的影响
  • C# 的 delegate/event/record/pattern matching 对模式的影响
  • 面试话术:被问「你用过什么设计模式」怎么答
  • 选型决策树与过度设计、模式滥用的信号清单

面试题索引

编号 题目 难度 状态 备注
01.3.2.13-001 七语言 × 常用模式族的落地矩阵总览 进阶 已完成 总表
01.3.2.13-002 一等函数如何替代策略模式与命令模式? 基础 已完成 lambda/delegate/闭包
01.3.2.13-003 闭包与装饰器语法如何替代 GoF 装饰器模式? 进阶 已完成 @decorator / 注解
01.3.2.13-004 接口、enum、模块系统如何替代抽象类、状态、单例? 进阶 已完成 语言特性替代
01.3.2.13-005 模式匹配如何替代访问者模式? 进阶 已完成 match / sum type
01.3.2.13-006 Go 的「少模式」哲学是什么?为什么不推崇经典 GoF? 高级 已完成 接口最小化
01.3.2.13-007 Rust 所有权如何改变结构型模式(代理、装饰器、组合)? 高级 已完成 借用与零成本
01.3.2.13-008 TypeScript 结构类型如何影响模式的表达? 进阶 已完成 鸭子类型的编译期版
01.3.2.13-009 Python 鸭子类型下哪些模式已经退化? 进阶 已完成 惯用写法
01.3.2.13-010 PHP 的 trait 如何影响代码复用模式? 进阶 已完成 横向复用
01.3.2.13-011 C# 的 delegate/event/record/pattern matching 对模式的影响 高级 已完成 语言特性整合
01.3.2.13-012 被问「你用过什么设计模式」怎么答才不像背题? 基础 已完成 面试话术
01.3.2.13-013 模式选型决策树与过度设计的信号清单 进阶 已完成 决策与反模式
01.3.2.13-014 同一个需求(支付渠道接入)在 Java、Go、Python 下的对比 进阶 已完成 三语言对照

01.3.2.13-001 七语言 × 常用模式族的落地矩阵总览

一句话结论

GoF 23 个模式在七语言里不是一一对应地实现,而是根据语言特性被「翻译」成不同形态:有的模式退化成语法糖,有的模式被框架/容器吸收,有的模式因为语言约束反而必须手写。下面这张总表是本页的核心参照。

概念解释

  • 模式族:创建型(单例、工厂、建造者)、结构型(代理、装饰器、适配器、外观、组合、桥接、享元)、行为型(策略、观察者、责任链、模板、命令、状态、迭代器、中介者、备忘录、访问者)。
  • 矩阵列:语言 / 创建型 / 结构型 / 行为型 / 最常见替代方式。
  • 这张表只标注「惯用形态」,不是「唯一正确写法」。

原理流程

  1. 先按问题域选模式族(创建/结构/行为)。
  2. 在矩阵里找到目标语言那一列,看惯用形态。
  3. 判断该形态是「手写类层次」还是「语言特性直接表达」。
  4. 结合团队与框架约定落地。

代码或图示

七语言 × 常用模式族矩阵:

| 模式族 | Java | Go | Python | TypeScript | Rust | C# | PHP |
|--------|------|----|---------|------------|------|----|-----|
| 单例 | 枚举/静态内部类 | sync.Once | 模块级实例 | 模块级 export | OnceLock | static/Lazy | 静态属性(请求级) |
| 工厂 | 抽象工厂+DI | 接口+构造函数 | 函数/类 | 工厂函数 | trait/泛型 | DI容器 | 容器绑定 |
| 策略 | 接口+lambda | 函数变量 | 函数一等 | 函数类型 | trait对象 | delegate | callable |
| 观察者 | Event/Listener | channel/回调 | 信号/事件总线 | EventEmitter | channel | event/delegate | 事件监听器 |
| 装饰器 | 装饰类/注解 | 函数包装 | @decorator | 装饰器语法 | 零成本封装 | 装饰器特性 | trait/注解 |
| 迭代器 | Iterable/Iterator | Next闭包 | 生成器 | Symbol.iterator | Iterator trait | IEnumerable/yield | Iterator/Generator |
| 状态 | 状态类 | enum+分支 | enum+dict | 联合类型+switch | enum+match | enum+switch | enum+switch |
| 访问者 | visitor类 | type switch | 单分派 | 类型守卫switch | match/sealed | pattern matching | 无内建,手动 |

常见误区

  • 以为矩阵是「标准答案」:它是惯用形态,项目历史与框架约定可能改变选择。
  • 忽略语言版本差异:pattern matching、sealed class、range-over-func 等特性都是版本相关,不确定时标「待确认」。
  • 把「替代」理解为「不需要」:替代的是机械类层次,模式的意图仍是设计词汇。

追问

  • 哪个语言的「手写类层次」需求最多?答:Java,因为它的反射、泛型、接口最完整,同时语言特性替代最少(直到 Java 17+ 才补齐 sealed/pattern matching)。
  • 哪个语言的「模式退化」最彻底?答:Python,鸭子类型 + 一等函数 + 装饰器语法让大多数 GoF 模式变成一两行惯用写法。

01.3.2.13-002 一等函数如何替代策略模式与命令模式?

一句话结论

当策略接口只有一个方法时,函数本身就是策略:Java 的 lambda、Go 的函数变量、Python 的函数对象、C# 的 Func<,>/delegate、Rust 的闭包都能直接替代策略类,省去接口与实现类的样板。

概念解释

  • 函数式接口:单方法接口,可被 lambda 直接赋值。
  • 闭包:携带上下文的函数对象,能捕获外部变量。
  • 命令模式同样:命令对象 = 一个有 execute 的函数,undo = 反向函数。

原理流程

  1. 定义函数类型(如 func(x int) int)。
  2. 调用方传入具体函数或 lambda。
  3. 上下文只持有函数引用,运行时调用。
  4. 需要状态时把状态包进闭包或参数对象。

代码或图示

// 策略:函数式接口替代策略类
public interface Discount {
    BigDecimal apply(BigDecimal price);
}

// 直接用 lambda
Discount vip = price -> price.multiply(BigDecimal.valueOf(0.9));
Discount normal = price -> price;
// Go:函数变量即策略
type Discount func(price float64) float64

var VipDiscount Discount = func(p float64) float64 { return p * 0.9 }
var NormalDiscount Discount = func(p float64) float64 { return p }
# Python:函数是一等公民,直接传
def vip_discount(price): return price * 0.9
def normal_discount(price): return price

def calc(price, discount): return discount(price)
// Rust:闭包 + trait 对象
fn calc(price: f64, discount: &dyn Fn(f64) -> f64) -> f64 {
    discount(price)
}

常见误区

  • 以为 lambda 能替代所有策略:策略有多个方法、需要注入依赖时,类仍然更清晰。
  • 在闭包里捕获可变变量:Rust 会要求 mut 与闭包类别(Fn/FnMut/FnOnce),Java 的 effectively final 也有限制。
  • 命令模式用函数后丢失了「记录命令元数据」的能力:需要记录时间、操作者、参数时,仍要包成对象。

追问

  • 为什么 Java 需要 @FunctionalInterface 而 Python 不需要?答:Java 是静态类型,函数式接口标注让编译器检查「单方法接口」;Python 运行时鸭子类型,任何可调用对象都能传。
  • 命令模式的 Undo 栈用函数怎么实现?答:栈里存 (do: Fn, undo: Fn) 两个函数对,执行时调 do,撤销时调 undo。

01.3.2.13-003 闭包与装饰器语法如何替代 GoF 装饰器模式?

一句话结论

GoF 装饰器用类层次层层包裹对象,现代语言用闭包或 @decorator 语法直接在函数外层包一层增强逻辑,省去 Decorator implements Component 的样板。

概念解释

  • GoF 装饰器:装饰类实现组件接口,内部持有组件实例,转发调用前后加逻辑。
  • 函数装饰器:接收一个函数,返回一个新函数,在原函数前后加逻辑。
  • 语言支持:Python 的 @decorator、TypeScript 的装饰器提案、Java 的注解 + AOP、C# 的特性 + 拦截器。

原理流程

  1. 定义装饰器函数:接收原函数,返回包装函数。
  2. 包装函数在调用前后插入日志、计时、权限等逻辑。
  3. 用 @decorator 语法或高阶函数应用到目标函数。
  4. 需要装饰类方法时,用类装饰器或 AOP 框架。

代码或图示

# Python:装饰器语法
import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time() - start:.2f}s")
        return result
    return wrapper

@timer
def query_db():
    pass
// TypeScript:装饰器语法(需 experimentalDecorators 或标准装饰器)
function logged(target: any, key: string, desc: PropertyDescriptor) {
    const original = desc.value;
    desc.value = function (...args: any[]) {
        console.log(`call ${key}`, args);
        return original.apply(this, args);
    };
}

class OrderService {
    @logged
    create() {}
}
// Java:注解 + AOP(Spring)
@Aspect
@Component
public class LogAspect {
    @Around("@annotation(org.springframework.web.bind.annotation.GetMapping)")
    public Object log(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object r = pjp.proceed();
        return r;
    }
}

常见误区

  • 以为装饰器语法 = GoF 装饰器:函数装饰器只装饰函数,GoF 装饰器装饰整个对象接口;类装饰器/AOP 才接近 GoF。
  • 在装饰器里丢失元信息:__name__、参数签名、类型注解会被包装函数遮蔽,需要 functools.wraps 或 Reflect。
  • 装饰器套太多层:执行顺序与调试栈变得难读,3 层以上要评审。

追问

  • Python 的类装饰器和函数装饰器区别?答:函数装饰器包装函数,类装饰器包装类(修改类的属性或方法),两者语法都是 @xxx。
  • Java 为什么不用函数装饰器而用注解 + AOP?答:Java 是静态类型 + 编译期,注解是元数据,AOP 在运行期或编译期织入,比函数装饰器更适合类层次。

01.3.2.13-004 接口、enum、模块系统如何替代抽象类、状态、单例?

一句话结论

接口替代抽象类的「多重继承」需求(Go、TypeScript),enum 替代状态模式的状态类层次(Java、C#、Rust),模块系统天然替代单例(Python、Go、TypeScript、Rust 的 OnceLock)。

概念解释

  • 接口替代抽象类:抽象类用继承复用代码,接口 + 组合用委托复用,更灵活。
  • enum 替代状态:每个状态是枚举项,行为用 switch 或枚举方法分发。
  • 模块替代单例:模块只加载一次,模块级变量天然唯一。

原理流程

  1. 需要「模板方法」时,先判断能否用组合 + 接口替代继承。
  2. 状态数量少时,用 enum + switch 比状态类层次更轻。
  3. 全局唯一对象,优先用模块级实例或容器单例,不要手写 GoF 单例。

代码或图示

// Rust:enum 替代状态模式
enum OrderState {
    Pending,
    Paid,
    Shipped,
    Done,
    Cancelled,
}

fn next(state: OrderState, event: &str) -> OrderState {
    match (state, event) {
        (OrderState::Pending, "pay") => OrderState::Paid,
        (OrderState::Paid, "ship") => OrderState::Shipped,
        (OrderState::Shipped, "confirm") => OrderState::Done,
        (s, _) => s,
    }
}
// TypeScript:模块系统天然单例
// config.ts
export const config = { dsn: "postgres://localhost/app" };
// 任何文件 import 都拿到同一对象
// Go:接口替代抽象类
type Reader interface {
    Read(p []byte) (int, error)
}

// 不需要抽象类,需要组合时直接嵌入接口
type ReadWriter interface {
    Reader
    Writer
}

常见误区

  • 以为 enum 能替代所有状态模式:状态行为复杂、状态间转移规则有继承关系时,状态类仍有价值。
  • 用模块系统做单例却忽略 SSR:Node 服务端模块常驻,模块级状态会跨请求共享,请求态数据不能放模块级。
  • 在 Go 里硬写抽象类:Go 没有继承,用接口 + 结构体嵌入组合才是惯用方式。

追问

  • 抽象类和接口的取舍?答:有共享代码且子类是「is-a」关系时用抽象类;只有行为契约时用接口。现代语言倾向接口 + 组合。
  • Rust 的 enum 为什么能替代状态模式?答:Rust 的 enum 可以带数据(sum type),match 穷尽检查保证所有状态都被处理,编译器帮你查漏。

01.3.2.13-005 模式匹配如何替代访问者模式?

一句话结论

访问者模式的核心是「按元素类型分发操作」,有模式匹配的语言用 match/switch 类型分支直接表达,不需要写 visitor 接口与 accept 方法;Rust 的 sum type + match 是最彻底的替代。

概念解释

  • 访问者:为每种元素类型写一个 visit(X) 方法,新增操作 = 新 visitor 类。
  • 模式匹配:match 表达式按类型/形状分支,新增操作 = 新写一个 match 函数。
  • 方向相同:两者都对「新增操作」开放、对「新增元素类型」封闭。

原理流程

  1. 把元素定义成 sum type(Rust enum、TypeScript 联合类型、C# 可空类型 + switch)。
  2. 写一个函数,内部 match 每个变体。
  3. 新增操作 = 新写一个 match 函数,不修改元素定义。
  4. 新增元素类型 = 编译器报错提醒所有 match 补充分支。

代码或图示

// Rust:sum type + match
enum Shape {
    Circle(f64),
    Square(f64),
}

fn area(s: &Shape) -> f64 {
    match s {
        Shape::Circle(r) => std::f64::consts::PI * r * r,
        Shape::Square(s) => s * s,
    }
}

// 新增操作:新写一个函数
fn perimeter(s: &Shape) -> f64 {
    match s {
        Shape::Circle(r) => 2.0 * std::f64::consts::PI * r,
        Shape::Square(s) => 4.0 * s,
    }
}
// TypeScript:联合类型 + 类型守卫
type Shape = { kind: "circle"; r: number } | { kind: "square"; s: number };

function area(s: Shape): number {
    switch (s.kind) {
        case "circle": return Math.PI * s.r * s.r;
        case "square": return s.s * s.s;
    }
}
// C#:模式匹配(版本相关,需确认当前语言版本)
double Area(Shape s) => s switch
{
    Circle c => Math.PI * c.R * c.R,
    Square sq => sq.S * sq.S,
    _ => throw new ArgumentException()
};

常见误区

  • 以为模式匹配能解决所有访问者问题:它只解决「按类型分发」,如果操作需要跨元素类型协作、或元素结构是对象树,访问者仍有价值。
  • 在 TypeScript 里忘记 never 检查:穷尽性靠编译器提示,新增变体时所有 switch 都会报错。
  • 以为 Java 没有模式匹配:Java 17+ 已支持 instanceof 模式与 switch 模式(具体版本以官方文档为准)。

追问

  • 访问者和模式匹配的开闭方向一样吗?答:一样——都对操作开放、对元素类型封闭。区别只是语法轻重。
  • 什么场景模式匹配替代不了访问者?答:元素类型来自第三方库、无法改成 sum type 时,访问者的外部扩展能力仍有价值。

01.3.2.13-006 Go 的「少模式」哲学是什么?为什么不推崇经典 GoF?

一句话结论

Go 推崇「显式优于隐式、组合优于继承、接口最小化」,不鼓励为模式而模式;GoF 里的很多模式在 Go 里要么用接口 + 函数变量直接表达,要么用 channel/select 解决,手写类层次反而违背 Go 的惯用风格。

概念解释

  • 接口最小化:Go 接口通常只有 1-3 个方法,io.Reader、io.Writer 是典范。
  • 组合优于继承:结构体嵌入实现代码复用,没有类继承。
  • Don't communicate by sharing memory; share memory by communicating(CSP):channel 替代共享状态与观察者。
  • 错误处理显式:if err != nil 替代异常与装饰器式错误包装。

原理流程

  1. 遇到问题先写最简单的实现。
  2. 发现重复出现的模式再抽象。
  3. 抽象优先用接口、函数变量、channel,而不是类层次。
  4. 代码评审时,「这里要不要加个设计模式」是反问句,不是默认动作。

代码或图示

// Go:接口 + 函数变量,不写策略类
type Promotion func(price float64) float64

func Vip() Promotion {
    return func(p float64) float64 { return p * 0.9 }
}

// 观察者:用 channel
type EventBus struct {
    subscribers []chan Event
}

func (b *EventBus) Publish(e Event) {
    for _, ch := range b.subscribers {
        ch <- e
    }
}
Go 不推崇的 GoF 模式:
- 抽象工厂:直接用构造函数
- 建造者:用可选参数模式(functional options)
- 装饰器:用函数包装
- 状态:用 enum + switch
- 访问者:用 type switch

常见误区

  • 把 Go 的「少模式」理解为「不需要设计」:它少的是机械类层次,不是设计思维。
  • 在 Go 里硬写 Java 式接口 + 实现类:Go 接口是隐式实现(鸭子类型),不需要 implements。
  • 用 channel 解决所有问题:channel 适合数据流,复杂状态协调仍需锁与结构体。

追问

  • Go 的 functional options 是什么?答:一组 func(*Options) 类型的可变参数,链式设置可选参数,替代建造者模式。
  • Go 为什么没有异常?答:显式错误返回让错误处理路径清晰,避免异常控制流被滥用。

01.3.2.13-007 Rust 所有权如何改变结构型模式(代理、装饰器、组合)?

一句话结论

Rust 的所有权与借用规则让「持有另一个对象的引用」成为编译期约束:代理不能随意持有 &T 或 &mut T,装饰器要么消费所有权要么用 trait 对象,组合通过 trait 与泛型在编译期完成,零运行时开销但需要显式标注生命周期。

概念解释

  • 所有权:每个值有唯一所有者,离开作用域即 drop。
  • 借用:&T 共享读、&mut T 独占写,不能同时存在。
  • 生命周期:引用必须有效,编译器静态检查。
  • 零成本抽象:trait + 泛型在编译期单态化,没有虚表开销。

原理流程

  1. 需要代理时,考虑是「持有值」还是「持有引用」。
  2. 持有值 = 消费所有权,代理拿到数据。
  3. 持有引用 = 标注生命周期,代理不拥有数据。
  4. 运行期多态 = Box<dyn Trait>,有虚表开销;编译期多态 = 泛型,零开销。

代码或图示

// Rust:装饰器用 trait 包装,编译期完成
trait Hello {
    fn hello(&self);
}

struct Inner;
impl Hello for Inner {
    fn hello(&self) { println!("inner"); }
}

struct LogDecorator<T: Hello>(T);
impl<T: Hello> Hello for LogDecorator<T> {
    fn hello(&self) {
        println!("before");
        self.0.hello();
        println!("after");
    }
}
// 代理:trait 对象(运行期多态)
fn run(hello: Box<dyn Hello>) {
    hello.hello();
}

常见误区

  • 以为 Rust 能随意持有引用:&T 必须有生命周期,不能存进结构体而不标注。
  • 到处用 Box<dyn Trait>:这是运行期多态,有虚表开销,能用泛型就用泛型。
  • 在代理里想同时持有 &mut T 和其他引用:借用规则会拒绝,需要重新设计数据所有权。

追问

  • Rust 怎么做「全局代理」?答:用 OnceLock + Mutex,把可变状态包进内部可变性。
  • Rust 的智能指针(Rc/Arc)和代理模式什么关系?答:它们是引用计数,让多个所有者共享数据,是「共享所有权」的语言级实现。

01.3.2.13-008 TypeScript 结构类型如何影响模式的表达?

一句话结论

TypeScript 是结构类型系统:只要对象形状匹配接口,就算实现了接口,不需要 implements 声明;这让模式的表达更轻——策略只要函数签名匹配,代理只要代理对象形状与原对象一致,不需要显式继承。

概念解释

  • 结构类型:按「形状」而不是「名字」判断类型兼容。
  • 鸭子类型的编译期版:运行时是 JS 鸭子类型,编译时 TS 检查形状。
  • 接口可以描述函数、对象、类,甚至联合类型。

原理流程

  1. 定义接口描述期望的形状。
  2. 任何对象只要形状匹配就自动满足接口。
  3. 不需要显式 implements,结构兼容即可。
  4. 模式的实现类可以是普通对象、类、函数,由编译器检查形状。

代码或图示

// 结构类型:只要形状匹配就算实现
interface Discount {
    (price: number): number;
}

const vip = (price: number) => price * 0.9; // 自动满足 Discount
const normal = (price: number) => price;

function calc(price: number, discount: Discount) {
    return discount(price);
}
// 代理:Proxy 内建
const target = { name: "ann", age: 30 };
const proxy = new Proxy(target, {
    get(t, key) {
        console.log(`read ${String(key)}`);
        return t[key as keyof typeof t];
    },
});

常见误区

  • 以为结构类型等于「运行时不检查」:编译期检查形状,运行时还是 JS 行为,类型断言要谨慎。
  • 用 implements 但忘记结构兼容才是本质:implements 只是编译期校验,不影响运行时。
  • 在代理里用 any:会丢失类型检查,代理对象应保持与原对象相同的类型。

追问

  • TypeScript 和 Java 的 nominal type 区别?答:Java 是名义类型,两个类即使形状相同也不兼容;TS 是结构类型,形状相同即兼容。
  • TS 怎么模拟 nominal type?答:用 brand 或唯一 symbol 给类型加标记,防止不同业务域的 ID 混用。

01.3.2.13-009 Python 鸭子类型下哪些模式已经退化?

一句话结论

Python 的鸭子类型 + 一等函数 + 装饰器语法 + 动态分发,让单例、策略、命令、装饰器、迭代器、访问者都退化成惯用写法:模块级实例、函数传参、闭包包装、@decorator、生成器、singledispatch,几乎不需要手写类层次。

概念解释

  • 鸭子类型:不关心对象类型,只关心它有没有需要的方法。
  • 一等函数:函数能当参数、返回值、赋值。
  • functools.singledispatch:按第一个参数类型分发,是 Python 版的访问者/重载。
  • 协议(Protocol):Python 3.8+ 的结构类型注解,让鸭子类型有编译期提示。

原理流程

  1. 需要策略 = 传一个函数。
  2. 需要装饰器 = 用 @decorator 语法。
  3. 需要迭代器 = 写生成器或实现 __iter__。
  4. 需要按类型分发 = 用 singledispatch 或 match(Python 3.10+)。

代码或图示

# Python:singledispatch 替代访问者
from functools import singledispatch

@singledispatch
def area(shape):
    raise NotImplementedError

@area.register
def _(shape: Circle):
    return 3.14 * shape.r ** 2

@area.register
def _(shape: Square):
    return shape.s ** 2
# Python:模块级单例
# config.py
class Config:
    dsn = "postgres://localhost/app"
config = Config()  # 模块只加载一次,天然单例

常见误区

  • 以为 Python 不需要设计模式:模式退化的是机械写法,设计思维(解耦、单一职责、开闭)仍然需要。
  • 在 Python 里硬写 Java 式类层次:过深的继承体系在动态语言里是维护负担。
  • 忽略运行时类型检查:鸭子类型意味着「以为有方法」可能在运行时才报错,需要测试覆盖或用 typing 注解。

追问

  • Python 的 match 语句(3.10+)和 singledispatch 怎么选?答:match 在函数内按形状分支,singledispatch 按类型注册多个函数;后者更适合跨模块扩展。
  • Python 的 __enter__/__exit__ 是哪种模式?答:是 RAII 的 Python 版,上下文管理器协议,替代 try/finally 样板。

01.3.2.13-010 PHP 的 trait 如何影响代码复用模式?

一句话结论

PHP 没有多继承,trait 提供了横向代码复用:把方法包进 trait,类 use 多个 trait,相当于「受限的多继承」;这让装饰器、策略、模板方法的公共逻辑可以横向复用,而不需要建继承树。

概念解释

  • trait:一组方法的集合,不能实例化,被类 use 后方法进入类。
  • 解决问题:PHP 单继承下,多个类需要同一组方法但不在同一继承链。
  • 与接口配合:接口定义契约,trait 提供默认实现。

原理流程

  1. 把公共方法抽进 trait。
  2. 需要的类 use trait。
  3. trait 内方法可以访问类的属性(通过 $this)。
  4. 多个 trait 冲突时用 insteadof 与 as 解决。

代码或图示

<?php
// trait:横向复用日志能力
trait Logger {
    public function log(string $msg): void {
        echo "[{$this->id}] {$msg}\n";
    }
}

class OrderService {
    use Logger;
    private int $id = 1;
}

class UserService {
    use Logger;
    private int $id = 2;
}
<?php
// trait + 接口:接口定义契约,trait 提供实现
interface Loggable {
    public function log(string $msg): void;
}

trait LoggableTrait {
    public function log(string $msg): void {
        echo $msg;
    }
}

class Service implements Loggable {
    use LoggableTrait;
}

常见误区

  • 把 trait 当多继承:trait 不能定义状态(属性冲突需要手动解决),也没有继承关系。
  • trait 互相 use trait:层数一多就变成「隐式继承」,难以追踪方法来源。
  • 在 trait 里写业务逻辑:trait 适合横切关注点(日志、缓存、校验),业务逻辑应留在类或服务里。

追问

  • PHP trait 和 Java 抽象类区别?答:抽象类是纵向继承树,trait 是横向组合;一个类只能继承一个抽象类,但可以 use 多个 trait。
  • Laravel 的 trait 用得多吗?答:很多,SoftDeletes、HasFactory、Notifiable 都是 trait,是 Laravel Eloquent 横切能力的核心。

01.3.2.13-011 C# 的 delegate/event/record/pattern matching 对模式的影响

一句话结论

C# 把多个模式的语言级整合做得最完整:delegate 替代策略/命令,event 替代观察者,record 替代值对象与备忘录快照,pattern matching 替代访问者;现代 C# 代码里手写 GoF 类层次越来越少。

概念解释

  • delegate:类型安全的函数指针,Func<,>/Action<> 替代策略接口。
  • event:基于 delegate 的观察者封装,外部只能 +=/-=。
  • record:值相等的不可变类型,天然适合做备忘录快照与 DTO。
  • pattern matching:switch 类型分支,替代访问者。

原理流程

  1. 需要策略 = 用 Func<,> 或自定义 delegate。
  2. 需要观察者 = 声明 event EventHandler<T>。
  3. 需要快照 = 定义 record,自动值相等与不可变。
  4. 需要按类型分发 = 用 switch 表达式模式匹配。

代码或图示

// delegate:策略
Func<decimal, decimal> vip = price => price * 0.9m;
decimal Calc(decimal price, Func<decimal, decimal> discount) => discount(price);
// event:观察者
public class OrderService {
    public event EventHandler<OrderEventArgs>? OnCreated;

    public void Create() {
        // ...
        OnCreated?.Invoke(this, new OrderEventArgs(orderId));
    }
}
// record:值对象 / 备忘录快照
public record OrderSnapshot(string OrderId, string Status, decimal Amount);

public class Order {
    private string _status = "pending";
    public OrderSnapshot Save() => new(Id, _status, Amount);
    public void Restore(OrderSnapshot s) => _status = s.Status;
}
// pattern matching:替代访问者
decimal Area(Shape s) => s switch {
    Circle c => Math.PI * c.R * c.R,
    Square sq => sq.S * sq.S,
    _ => throw new ArgumentException()
};

常见误区

  • 以为 event 是 delegate:event 是对 delegate 的封装,外部不能直接 Invoke,只能订阅/退订。
  • record 当可变类用:record 默认不可变(init -only 属性),需要可变时用 record class。
  • pattern matching 的版本依赖:C# 8/9/10 陆续加入,具体语法以项目目标语言版本为准。

追问

  • C# 的 record struct 和 record class 区别?答:record struct 是值类型,record class 是引用类型;值相等语义两者都有。
  • C# 的 IObservable<T> 是什么?答:Rx 库的推模式观察者,比 event 更强大,支持组合与异步。

01.3.2.13-012 被问「你用过什么设计模式」怎么答才不像背题?

一句话结论

不要背「我用过单例、工厂、策略……」清单,要讲「在什么问题上、用了什么模式、解决了什么、为什么不用其他方案」——用场景 + 决策 + 取舍说话,模式只是术语标签。

概念解释

  • 错误答法:「我用过单例、工厂、策略、观察者、责任链……」——像背目录。
  • 正确答法:「这个需求里,X 变化频繁,我用了策略模式把 X 抽出来,新增 X 不改主干;Y 是横切关注点,用装饰器/AOP 包;Z 需要撤销,用命令栈。」
  • 关键:每个模式都要配一个「为什么是它而不是更简单的方案」。

原理流程

  1. 先讲业务场景与变化点。
  2. 再讲你识别出的问题类型(解耦、扩展、复用、撤销)。
  3. 然后说用了什么模式、怎么落地。
  4. 最后说取舍:为什么没用更简单的方案、什么时候会改回来。

代码或图示

话术模板:
"在 [项目] 里,[某类逻辑] 会随 [业务线] 频繁变化,
 如果直接写 if/else 会让主干越来越长。
 我把变化部分抽成 [策略/接口],新增 [业务线] 时
 只加一个实现并注册到 [Map/容器],主干不动。
 另外 [横切逻辑] 用了 [AOP/装饰器/事件],
 不污染业务代码。
 后来 [某个边界场景] 出现时,
 我们发现 [原方案] 在 [X] 上有成本,
 就改成了 [更简单的方案]。"

常见误区

  • 把每个模式都讲一遍:面试官要听的是「你怎么思考」,不是「你认识多少模式」。
  • 只讲「用了什么」不讲「为什么不用别的」:取舍才是设计能力的体现。
  • 讲框架内置的模式当自己的设计:Spring 的 JdbcTemplate 是模板方法,但这是框架提供的,你要讲的是你在业务代码里做的决策。

追问

  • 面试官追问「你为什么不用更简单的方案」怎么答?答:准备一个「如果只有两个分支我就直接 if/else」的反例,证明你知道什么时候该上模式。
  • 完全没用过设计模式怎么办?答:讲你在重构里「去掉」模式的经历——「这段代码一开始套了策略,后来分支收敛了,我改成了 enum 分支」,这同样是设计能力。

01.3.2.13-013 模式选型决策树与过度设计的信号清单

一句话结论

选型从「变化点在哪」出发:变化频繁的地方抽接口/策略,横切关注点用装饰器/AOP,需要撤销用命令栈,需要解耦通知用观察者;过度设计的信号是「类比业务多」「改一行要动三个文件」「模式之间互相不知道对方存在」。

概念解释

  • 决策树:先识别变化点类型,再匹配模式族,再判断语言是否有特性替代。
  • 过度设计信号:为未来可能的需求提前抽象、模式层次深但职责单一、新人看不懂为什么要绕一层。
  • 简单优先:能用 if/else、enum、函数解决的,不要上类层次。

原理流程

  1. 问:变化点是什么?算法?通知?流程?状态?遍历?
  2. 问:变化频率?一次两次?还是每月都加?
  3. 问:语言有没有特性替代?(lambda、enum、match、模块)
  4. 问:去掉模式后代码会恶化吗?不会就别加。

代码或图示

决策树:
变化点 = 算法可互换?
  → 是:策略(接口)/ 函数变量(语言特性)
  → 否:继续
变化点 = 横切关注点?
  → 是:装饰器 / AOP / 注解
  → 否:继续
变化点 = 状态迁移?
  → 是:enum + switch(状态少)/ 状态类(状态多)
  → 否:继续
变化点 = 需要记录/撤销?
  → 是:命令栈 / 备忘录快照
  → 否:继续
变化点 = 多对象网状交互?
  → 是:中介者 / 事件总线
  → 否:继续
过度设计信号:
- 一个需求拆了 5 个类,但每个类只有 3 行
- 新增一个业务要改 3 个文件,其中 2 个是模式基础设施
- 类名里有 Manager/Helper/Utils 但职责不清
- 面试官/同事问「这里为什么要抽一层」时,答不出「因为 X 会变」
- 为「未来可能加的分支」提前定义了接口

常见误区

  • 把「模式多」当成「设计好」:设计能力是知道什么时候不用模式。
  • 抽象太早:YAGNI(You Aren't Gonna Need It),第三次出现重复再抽象。
  • 用模式解决「不会改」的问题:稳定的业务直接写最简单的代码。

追问

  • 怎么判断「第三次出现重复再抽象」?答:前两次复制,第三次重构;过早抽象会导致抽象方向错误。
  • 过度设计怎么重构?答:合并职责单一的类、内联不必要的接口、把模式基础设施改成直接调用,保持测试通过。

01.3.2.13-014 同一个需求(支付渠道接入)在 Java、Go、Python 下的对比

一句话结论

支付渠道接入的核心是「渠道可互换、新增渠道不改主干」——Java 用接口 + Spring DI 注册策略,Go 用接口 + 构造函数手动注入,Python 用函数/类 + 注册表 dict;三者意图相同,落地形态随语言特性差异明显。

概念解释

  • 需求:支持支付宝、微信支付、银联,后续可能加新渠道。
  • 变化点:每个渠道的签名、请求、回调处理不同。
  • 稳定点:支付下单、查询、退款的主干流程。
  • 选型:策略模式 + 注册表。

原理流程

  1. 定义支付渠道接口:pay(order)、query(order)、refund(order)。
  2. 每个渠道一个实现。
  3. 主干流程从注册表按渠道类型取实现。
  4. 新增渠道 = 加一个实现 + 注册,主干不动。

代码或图示

// Java:接口 + Spring 自动注册
public interface PaymentChannel {
    String type();
    PayResult pay(Order order);
}

@Component
public class AlipayChannel implements PaymentChannel {
    public String type() { return "alipay"; }
    public PayResult pay(Order o) { /* ... */ }
}

@Service
public class PaymentService {
    private final Map<String, PaymentChannel> channels;

    public PaymentService(List<PaymentChannel> list) {
        this.channels = list.stream()
            .collect(Collectors.toMap(PaymentChannel::type, c -> c));
    }

    public PayResult pay(String type, Order o) {
        return channels.get(type).pay(o);
    }
}
// Go:接口 + 手动构造
type PaymentChannel interface {
    Type() string
    Pay(o *Order) (*PayResult, error)
}

type PaymentService struct {
    channels map[string]PaymentChannel
}

func NewPaymentService(channels ...PaymentChannel) *PaymentService {
    m := make(map[string]PaymentService)
    for _, c := range channels {
        m[c.Type()] = c
    }
    return &PaymentService{channels: m}
}

func (s *PaymentService) Pay(t string, o *Order) (*PayResult, error) {
    ch, ok := s.channels[t]
    if !ok {
        return nil, fmt.Errorf("unknown channel: %s", t)
    }
    return ch.Pay(o)
}
# Python:函数/类 + 注册表
class PaymentChannel:
    def type(self) -> str: ...
    def pay(self, order: dict) -> dict: ...

class AlipayChannel(PaymentChannel):
    def type(self) -> str: return "alipay"
    def pay(self, order: dict) -> dict: return {"status": "ok"}

class PaymentService:
    def __init__(self, channels: list[PaymentChannel]):
        self._channels = {c.type(): c for c in channels}

    def pay(self, channel_type: str, order: dict) -> dict:
        return self._channels[channel_type].pay(order)

常见误区

  • 把渠道的 HTTP 调用细节写进主干:主干只调度,渠道细节在各自实现里。
  • 忘记处理「未知渠道」:注册表取不到时要返回明确错误,不能空指针。
  • 在 Go 里用全局变量存注册表:应通过构造函数注入,方便测试与替换。

追问

  • 新增渠道时为什么不用工厂方法?答:这里用注册表更简单——工厂是「按类型创建对象」,注册表是「按类型取已有对象」,策略无状态时注册表更轻。
  • 支付渠道需要异步回调怎么扩展?答:接口加 handleCallback(notify) 方法,每个渠道自己实现验签与回调处理,主干不感知。

跨语言差异对照

语言 惯用实现 差异要点
Java 接口 + Spring DI / 函数式接口 框架自动收集策略;lambda 替代简单策略类;sealed class + pattern matching 逐步替代访问者
Go 接口 + 函数变量 + 手动构造注入 无继承;接口隐式实现;functional options 替代建造者;channel 替代观察者
Python 函数一等 + 模块 + @decorator + singledispatch 鸭子类型;模式退化最彻底;模块级单例;生成器即迭代器
TypeScript/JS 函数类型 + 结构类型 + Proxy + 装饰器提案 结构类型;模块级单例;Proxy 内建代理;联合类型 + switch 替代访问者
Rust trait + 泛型 + enum + match + 智能指针 编译期单态化零成本;sum type + match 最彻底替代访问者;所有权约束代理与装饰器
C#/.NET delegate/event/record/pattern matching + DI 容器 语言特性整合最完整;record 天然值对象;IAsyncEnumerable 异步流式
PHP 接口 + trait + 容器 + 注解 trait 横向复用;FPM 请求级生命周期;Laravel 容器自动绑定

七语言 × 模式族总矩阵

模式族 Java Go Python TypeScript Rust C# PHP
单例 枚举/静态内部类 sync.Once 模块级实例 模块 export OnceLock static/Lazy 静态属性(请求级)
工厂 抽象工厂 + DI 构造函数 函数/类 工厂函数 trait/泛型 DI 容器 容器绑定
策略 接口 + lambda 函数变量 函数传参 函数类型 trait 对象/闭包 Func<,> callable
观察者 Event/Listener channel/回调 信号/事件总线 EventEmitter channel event/delegate 事件监听器
装饰器 装饰类/AOP 函数包装 @decorator 装饰器语法 trait 封装 特性 + 拦截器 trait/注解
迭代器 Iterable/Iterator Next() 闭包 生成器 Symbol.iterator Iterator trait IEnumerable/yield Iterator/Generator
状态 状态类 enum + switch enum + dict 联合类型 + switch enum + match enum + switch enum + switch
访问者 visitor 类 type switch singledispatch/match 类型守卫 switch match/sum type pattern matching 手动分发

跨语言差异

  • Java 与 C# 是「语言特性整合」的两个方向:Java 靠框架(Spring)补全模式,C# 靠语言本身(delegate/event/record)整合。
  • Go 与 Rust 是「少模式」的两个方向:Go 靠接口最小化 + 函数变量,Rust 靠 trait + 所有权把模式做成编译期约束。
  • Python 与 TypeScript 是「动态/结构化类型」的两个方向:Python 运行时鸭子类型,TypeScript 编译期结构检查,两者都让模式退化。
  • PHP 的 trait 是单继承语言里横向复用的特殊解,与其他语言的「组合 + 委托」思路不同。
  • 选型决策时,先看语言特性是否已经替代,再决定是否手写类层次;手写类层次是最后选项,不是默认动作。

待整理清单

  • [ ] 补充 Kotlin object/sealed class/data class 对模式的替代
  • [ ] 补充 Swift enum、pattern matching 与 Rust 的对照
  • [ ] 补充各语言在 GraalVM native image、AOT 编译下模式的行为差异
  • [ ] 补充「过度设计」在真实项目中的重构案例与前后对比