📌 第一部分：设计模式概览与定位

1.1 定义与全称

设计模式（Design Patterns）是软件开发中针对常见问题的可复用解决方案，由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides（"GoF 四人组"）于 1994 年在《设计模式：可复用面向对象软件的基础》一书中系统化提出。

1.2 核心定位

设计模式的核心定位是 代码设计的最佳实践。它提供了：

• 可复用的设计方案
• 经过验证的解决方案
• 通用的设计语言（开发团队沟通）
• 代码可维护性和可扩展性
• 降低系统复杂度
• 提高代码复用率

1.3 三大分类

• 创建型模式： 对象创建机制（5 种）
• 结构型模式： 类和对象的组合（7 种）
• 行为型模式： 对象间的职责分配（11 种）

1.4 设计原则（SOLID）

• S - 单一职责原则（SRP）： 一个类只负责一个职责
• O - 开闭原则（OCP）： 对扩展开放，对修改关闭
• L - 里氏替换原则（LSP）： 子类可以替换父类
• I - 接口隔离原则（ISP）： 接口应该小而专
• D - 依赖倒置原则（DIP）： 依赖抽象而非具体实现

---

🏗️ 第二部分：创建型模式（5 种）

2.1 单例模式（Singleton）

• 目的： 确保一个类只有一个实例
• 适用场景： 全局配置、连接池、日志管理器

// Java 单例模式（双重检查锁）
public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// PHP 单例模式
class Singleton {
    private static $instance = null;

    private function __construct() {}

    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

2.2 工厂模式（Factory）

• 目的： 创建对象而不暴露创建逻辑
• 适用场景： 对象创建复杂、需要解耦

// Java 工厂模式
interface Product {
    void use();
}

class ProductA implements Product {
    public void use() { System.out.println("Product A"); }
}

class ProductB implements Product {
    public void use() { System.out.println("Product B"); }
}

class ProductFactory {
    public static Product create(String type) {
        switch (type) {
            case "A": return new ProductA();
            case "B": return new ProductB();
            default: throw new IllegalArgumentException();
        }
    }
}

// 使用
Product p = ProductFactory.create("A");
p.use();

2.3 抽象工厂模式（Abstract Factory）

• 目的： 创建一系列相关或依赖的对象
• 适用场景： 产品族、跨平台 UI 组件

2.4 建造者模式（Builder）

• 目的： 分步构建复杂对象
• 适用场景： 对象有多个可选参数

// Java 建造者模式
public class User {
    private final String name;
    private final int age;
    private final String email;
    private final String phone;

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

    public static class Builder {
        private final String name;
        private int age;
        private String email;
        private String phone;

        public Builder(String name) { this.name = name; }

        public Builder age(int age) { this.age = age; return this; }
        public Builder email(String email) { this.email = email; return this; }
        public Builder phone(String phone) { this.phone = phone; return this; }

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

// 使用
User user = new User.Builder("Alice")
    .age(30)
    .email("alice@example.com")
    .build();

2.5 原型模式（Prototype）

• 目的： 通过复制现有对象创建新对象
• 适用场景： 对象创建成本高

---

🔗 第三部分：结构型模式（7 种）

3.1 适配器模式（Adapter）

• 目的： 让不兼容的接口协同工作
• 适用场景： 集成第三方库、遗留系统

// Java 适配器模式
interface Target {
    void request();
}

class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee request");
    }
}

class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

3.2 装饰器模式（Decorator）

• 目的： 动态添加功能
• 适用场景： 扩展功能而不修改原类

// Java 装饰器模式（以咖啡为例）
interface Coffee {
    double cost();
    String description();
}

class SimpleCoffee implements Coffee {
    public double cost() { return 5.0; }
    public String description() { return "Simple Coffee"; }
}

class MilkDecorator implements Coffee {
    private Coffee coffee;

    public MilkDecorator(Coffee coffee) { this.coffee = coffee; }

    public double cost() { return coffee.cost() + 1.5; }
    public String description() { return coffee.description() + ", Milk"; }
}

// 使用
Coffee coffee = new SimpleCoffee();
coffee = new MilkDecorator(coffee);
// cost = 6.5, description = "Simple Coffee, Milk"

3.3 代理模式（Proxy）

• 目的： 控制对对象的访问
• 适用场景： 延迟加载、权限控制、缓存

3.4 外观模式（Facade）

• 目的： 提供简化接口
• 适用场景： 复杂子系统封装

3.5 桥接模式（Bridge）

• 目的： 抽象与实现分离
• 适用场景： 多维度变化

3.6 组合模式（Composite）

• 目的： 树形结构表示
• 适用场景： 菜单、文件系统

3.7 享元模式（Flyweight）

• 目的： 共享细粒度对象
• 适用场景： 大量相似对象

---

🔄 第四部分：行为型模式（11 种）

4.1 观察者模式（Observer）

• 目的： 对象间的一对多依赖
• 适用场景： 事件监听、发布订阅

// Java 观察者模式
interface Observer {
    void update(String message);
}

class User implements Observer {
    private String name;

    public User(String name) { this.name = name; }

    @Override
    public void update(String message) {
        System.out.println(name + " received: " + message);
    }
}

class NewsPublisher {
    private List observers = new ArrayList<>();

    public void subscribe(Observer observer) {
        observers.add(observer);
    }

    public void publish(String news) {
        for (Observer observer : observers) {
            observer.update(news);
        }
    }
}

// 使用
NewsPublisher publisher = new NewsPublisher();
publisher.subscribe(new User("Alice"));
publisher.subscribe(new User("Bob"));
publisher.publish("Breaking News!");

4.2 策略模式（Strategy）

• 目的： 算法可互换
• 适用场景： 支付方式、排序算法

// Java 策略模式
interface PaymentStrategy {
    void pay(int amount);
}

class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " with Credit Card");
    }
}

class PayPalPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " with PayPal");
    }
}

class ShoppingCart {
    private PaymentStrategy strategy;

    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void checkout(int amount) {
        strategy.pay(amount);
    }
}

// 使用
ShoppingCart cart = new ShoppingCart();
cart.setStrategy(new CreditCardPayment());
cart.checkout(100);

4.3 模板方法模式（Template Method）

• 目的： 定义算法骨架
• 适用场景： 流程固定、步骤可变

4.4 命令模式（Command）

• 目的： 将请求封装为对象
• 适用场景： 命令队列、撤销操作

4.5 责任链模式（Chain of Responsibility）

• 目的： 请求沿链传递
• 适用场景： 中间件、过滤器

4.6 状态模式（State）

• 目的： 状态改变行为
• 适用场景： 订单状态、工作流

4.7 访问者模式（Visitor）

• 目的： 在不修改类的前提下添加操作

4.8 迭代器模式（Iterator）

• 目的： 遍历集合

4.9 中介者模式（Mediator）

• 目的： 对象间通信解耦

4.10 备忘录模式（Memento）

• 目的： 保存和恢复状态

4.11 解释器模式（Interpreter）

• 目的： 定义语言语法

---

📋 第五部分：常用模式速查表

模式	分类	使用频率	典型场景
单例模式	创建型	⭐⭐⭐⭐⭐	全局配置、连接池
工厂模式	创建型	⭐⭐⭐⭐⭐	对象创建、依赖注入
建造者模式	创建型	⭐⭐⭐⭐	复杂对象构建
适配器模式	结构型	⭐⭐⭐⭐⭐	接口兼容、遗留系统
装饰器模式	结构型	⭐⭐⭐⭐	动态扩展功能
代理模式	结构型	⭐⭐⭐⭐	延迟加载、缓存
观察者模式	行为型	⭐⭐⭐⭐⭐	事件驱动、发布订阅
策略模式	行为型	⭐⭐⭐⭐⭐	算法切换、支付方式
模板方法	行为型	⭐⭐⭐⭐	流程固定、步骤可变
责任链模式	行为型	⭐⭐⭐⭐	中间件、过滤器
状态模式	行为型	⭐⭐⭐	订单状态、工作流

---

🧠 第六部分：学习建议

推荐书籍与资源

• 《设计模式：可复用面向对象软件的基础》—— GoF 经典
• 《Head First 设计模式》—— 最易入门的书
• 《设计模式之美》—— 王争 著
• Refactoring Guru： refactoring.guru（在线资源）
• Source Making： sourcemaking.com

---

🎯 总结升华