一次性搞懂常见设计模式（通俗版 + 优雅代码示例）

这篇只讲“常用、能落地”的那批设计模式，每个模式都给一句话场景 + 简洁示例代码。

---

一、创建型（怎么造对象）

1. 单例（Singleton）

场景：全局只要一个对象，比如配置中心。

public final class ConfigCenter {
    // 饿汉式：类加载即创建，线程安全
    private static final ConfigCenter INSTANCE = new ConfigCenter();

    private ConfigCenter() {}

    public static ConfigCenter getInstance() {
        return INSTANCE;
    }
}

---

2. 工厂方法（Factory Method）

场景：不同类型对象的创建逻辑不一样。

interface Pay {
    void pay(int amount);
}

class WechatPay implements Pay {
    public void pay(int amount) {}
}

class AliPay implements Pay {
    public void pay(int amount) {}
}

class PayFactory {
    public static Pay create(String type) {
        return switch (type) {
            case "wechat" -> new WechatPay();
            case "alipay" -> new AliPay();
            default -> throw new IllegalArgumentException("unknown pay");
        };
    }
}

---

3. 建造者（Builder）

场景：对象参数很多，构造容易出错。

class User {
    private final String name;
    private final int age;
    private final String email;

    private User(Builder b) {
        this.name = b.name;
        this.age = b.age;
        this.email = b.email;
    }

    static class Builder {
        private String name;
        private int age;
        private String email;

        Builder name(String v) { this.name = v; return this; }
        Builder age(int v) { this.age = v; return this; }
        Builder email(String v) { this.email = v; return this; }

        User build() { return new User(this); }
    }
}

---

二、结构型（怎么组织对象）

4. 适配器（Adapter）

场景：老接口不改，包装成新接口。

interface NewApi {
    String read();
}

class Legacy {
    String getText() { return "old"; }
}

class LegacyAdapter implements NewApi {
    private final Legacy legacy = new Legacy();

    public String read() {
        return legacy.getText();
    }
}

---

5. 装饰器（Decorator）

场景：给功能加“外套”，不动原类。

interface Logger {
    void log(String msg);
}

class ConsoleLogger implements Logger {
    public void log(String msg) {}
}

class JsonLogger implements Logger {
    private final Logger delegate;
    JsonLogger(Logger delegate) { this.delegate = delegate; }

    public void log(String msg) {
        delegate.log("{\"msg\":\"" + msg + "\"}");
    }
}

---

6. 代理（Proxy）

场景：对象访问前后要做控制或增强。

interface Service {
    void doWork();
}

class RealService implements Service {
    public void doWork() {}
}

class AuthProxy implements Service {
    private final Service target;
    AuthProxy(Service target) { this.target = target; }

    public void doWork() {
        // 前置校验
        target.doWork();
        // 后置审计
    }
}

---

三、行为型（怎么协作）

7. 策略（Strategy）

场景：算法可替换，比如不同优惠计算。

interface DiscountStrategy {
    int calc(int price);
}

class VipDiscount implements DiscountStrategy {
    public int calc(int price) { return (int)(price * 0.8); }
}

class NormalDiscount implements DiscountStrategy {
    public int calc(int price) { return price; }
}

class PriceService {
    private final DiscountStrategy strategy;
    PriceService(DiscountStrategy s) { this.strategy = s; }

    int finalPrice(int price) { return strategy.calc(price); }
}

---

8. 模板方法（Template Method）

场景：固定流程，局部步骤可变。

abstract class Exporter {
    // 固定流程
    public final void export() {
        readData();
        format();
        writeFile();
    }

    protected abstract void format();

    private void readData() {}
    private void writeFile() {}
}

class CsvExporter extends Exporter {
    protected void format() {}
}

---

9. 观察者（Observer）

场景：事件通知，比如订单状态变化。

interface Listener {
    void onEvent(String event);
}

class EventBus {
    private final List<Listener> listeners = new ArrayList<>();
    void register(Listener l) { listeners.add(l); }
    void publish(String e) { listeners.forEach(l -> l.onEvent(e)); }
}

---

10. 责任链（Chain of Responsibility）

场景：请求一层层过滤。

abstract class Handler {
    protected Handler next;
    void setNext(Handler n) { this.next = n; }
    abstract void handle(String req);
}

class AuthHandler extends Handler {
    void handle(String req) {
        // 校验
        if (next != null) next.handle(req);
    }
}

---

11. 状态（State）

场景：状态驱动行为变化。

interface OrderState {
    void next(Order ctx);
}

class Unpaid implements OrderState {
    public void next(Order ctx) { ctx.setState(new Paid()); }
}

class Paid implements OrderState {
    public void next(Order ctx) { ctx.setState(new Shipped()); }
}

class Order {
    private OrderState state = new Unpaid();
    void setState(OrderState s) { this.state = s; }
    void next() { state.next(this); }
}

---

最后总结

设计模式不是为了“背”，而是为了写出可扩展、可维护的代码。
遇到问题时，先想一句话：“我现在最想消除的复杂度是哪一类？”
再选对应的模式，会更自然。