设计模式全解析：23种经典设计模式及其应用

北漂老男孩2025-04-29 19:49

创建型模式

1. 单例模式（Singleton Pattern）

  • 核心思想：确保一个类只有一个实例，并提供一个全局访问点。
  • 适用场景：需要共享资源的场景，如配置管理、日志记录等。
java 复制代码 
public class Singleton {
    // 静态变量保存单例实例
    private static Singleton instance;

    // 私有构造函数，防止外部实例化
    private Singleton() {}

    // 提供获取实例的全局访问点
    public static Singleton getInstance() {
        if (instance == null) { // 如果实例为空，则创建
            instance = new Singleton();
        }
        return instance; // 返回单例实例
    }
}

2. 工厂方法模式（Factory Method Pattern）

  • 核心思想：定义一个创建对象的接口，但由子类决定实例化哪一个类。
  • 适用场景：需要延迟到子类进行对象实例化时。
java 复制代码 
// 产品接口
interface Product {}

// 具体产品类
class ConcreteProduct implements Product {}

// 工厂接口
interface Creator {
    Product factoryMethod(); // 工厂方法，用于创建产品
}

// 具体工厂类
class ConcreteCreator implements Creator {
    public Product factoryMethod() {
        return new ConcreteProduct(); // 返回具体产品实例
    }
}

3. 抽象工厂模式（Abstract Factory Pattern）

  • 核心思想：提供一个接口，创建一系列相关或依赖对象，而无需指定具体类。
  • 适用场景：需要创建一组相关或互相依赖的对象时。
java 复制代码 
// 抽象产品A
interface ProductA {}

// 抽象产品B
interface ProductB {}

// 具体产品A1
class ProductA1 implements ProductA {}

// 具体产品B1
class ProductB1 implements ProductB {}

// 抽象工厂接口
interface AbstractFactory {
    ProductA createProductA(); // 创建产品A的方法
    ProductB createProductB(); // 创建产品B的方法
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA1(); // 创建具体产品A1
    }
    public ProductB createProductB() {
        return new ProductB1(); // 创建具体产品B1
    }
}

4. 建造者模式（Builder Pattern）

  • 核心思想：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
  • 适用场景：需要构建复杂对象时，且构建过程独立于表示。
java 复制代码 
// 产品类
class Product {
    private String partA;
    private String partB;

    // 设置部件A
    public void setPartA(String partA) {
        this.partA = partA;
    }

    // 设置部件B
    public void setPartB(String partB) {
        this.partB = partB;
    }
}

// 建造者接口
interface Builder {
    void buildPartA(); // 构建部件A
    void buildPartB(); // 构建部件B
    Product getResult(); // 获取构建的产品
}

// 具体建造者
class ConcreteBuilder implements Builder {
    private Product product = new Product();

    public void buildPartA() {
        product.setPartA("PartA"); // 设置产品的部件A
    }

    public void buildPartB() {
        product.setPartB("PartB"); // 设置产品的部件B
    }

    public Product getResult() {
        return product; // 返回构建的产品
    }
}

5. 原型模式（Prototype Pattern）

  • 核心思想：通过复制现有实例来创建新对象，避免重复初始化。
  • 适用场景：需要大量相似对象时。
java 复制代码 
// 原型类
class Prototype implements Cloneable {
    // 克隆方法
    public Prototype clone() throws CloneNotSupportedException {
        return (Prototype) super.clone(); // 调用父类的克隆方法
    }
}

结构型模式

6. 适配器模式（Adapter Pattern）

  • 核心思想：将一个类的接口转换成客户期望的另一个接口。
  • 适用场景：接口不兼容但需要协同工作的类。
java 复制代码 
// 目标接口
interface Target {
    void request();
}

// 被适配的类
class Adaptee {
    void specificRequest() {
        // 特殊请求
    }
}

// 适配器类
class Adapter implements Target {
    private Adaptee adaptee;

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

    public void request() {
        adaptee.specificRequest(); // 转发请求到被适配对象
    }
}

7. 桥接模式（Bridge Pattern）

  • 核心思想：将抽象部分与实现部分分离，使它们可以独立变化。
  • 适用场景：需要跨越多个平台的对象。
java 复制代码 
// 实现接口
interface Implementor {
    void operationImpl();
}

// 具体实现类A
class ConcreteImplementorA implements Implementor {
    public void operationImpl() {
        // 具体实现
    }
}

// 抽象类
abstract class Abstraction {
    protected Implementor implementor;

    protected Abstraction(Implementor implementor) {
        this.implementor = implementor;
    }

    public abstract void operation(); // 抽象方法
}

// 扩展抽象类
class RefinedAbstraction extends Abstraction {
    public RefinedAbstraction(Implementor implementor) {
        super(implementor);
    }

    public void operation() {
        implementor.operationImpl(); // 调用实现方法
    }
}

8. 组合模式（Composite Pattern）

  • 核心思想：将对象组合成树形结构以表示"部分-整体"的层次结构。
  • 适用场景：需要处理树形结构数据时。
java 复制代码 
// 组件接口
interface Component {
    void operation();
}

// 叶子节点
class Leaf implements Component {
    public void operation() {
        // 叶子节点的操作
    }
}

// 组合节点
class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    // 添加子节点
    public void add(Component component) {
        children.add(component);
    }

    public void operation() {
        for (Component child : children) {
            child.operation(); // 递归调用子节点的操作
        }
    }
}

9. 装饰器模式（Decorator Pattern）

  • 核心思想：动态地给对象添加一些额外的职责。
  • 适用场景：需要扩展类的功能时。
java 复制代码 
// 组件接口
interface Component {
    void operation();
}

// 具体组件
class ConcreteComponent implements Component {
    public void operation() {
        // 基本操作
    }
}

// 装饰器抽象类
abstract class Decorator implements Component {
    protected Component component;

    protected Decorator(Component component) {
        this.component = component;
    }

    public void operation() {
        component.operation(); // 调用被装饰对象的操作
    }
}

// 具体装饰器
class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    public void operation() {
        super.operation();
        // 添加额外的操作
    }
}

10. 外观模式（Facade Pattern）

  • 核心思想：为子系统中的一组接口提供一个一致的界面。
  • 适用场景：简化复杂系统的使用。
java 复制代码 
// 子系统A
class SubsystemA {
    void operationA() {
        // 子系统A的操作
    }
}

// 子系统B
class SubsystemB {
    void operationB() {
        // 子系统B的操作
    }
}

// 外观类
class Facade {
    private SubsystemA subsystemA = new SubsystemA();
    private SubsystemB subsystemB = new SubsystemB();

    // 提供的统一接口
    void operation() {
        subsystemA.operationA(); // 调用子系统A的方法
        subsystemB.operationB(); // 调用子系统B的方法
    }
}

11. 享元模式（Flyweight Pattern）

  • 核心思想：运用共享技术有效地支持大量细粒度对象。
  • 适用场景：需要大量创建对象时，减少内存消耗。
java 复制代码 
// 享元类
class Flyweight {
    private String intrinsicState; // 内部状态

    public Flyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    // 操作方法，传入外部状态
    void operation(String extrinsicState) {
        // 使用内部状态和外部状态
    }
}

// 享元工厂
class FlyweightFactory {
    private Map<String, Flyweight> flyweights = new HashMap<>();

    // 获取享元对象
    public Flyweight getFlyweight(String key) {
        if (!flyweights.containsKey(key)) {
            flyweights.put(key, new Flyweight(key)); // 创建新享元对象
        }
        return flyweights.get(key); // 返回享元对象
    }
}

12. 代理模式（Proxy Pattern）

  • 核心思想：为其他对象提供一种代理，以控制对这个对象的访问。
  • 适用场景：需要控制对象访问权限时。
java 复制代码 
// 抽象主题
interface Subject {
    void request();
}

// 真实主题
class RealSubject implements Subject {
    public void request() {
        // 真实请求的处理
    }
}

// 代理类
class Proxy implements Subject {
    private RealSubject realSubject;

    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject(); // 延迟初始化
        }
        realSubject.request(); // 转发请求
    }
}

行为型模式

13. 责任链模式（Chain of Responsibility Pattern）

  • 核心思想：避免请求发送者与接收者耦合，让多个对象都有机会处理请求。
  • 适用场景：请求需要多个对象处理时。
java 复制代码 
// 处理者抽象类
abstract class Handler {
    protected Handler successor; // 后继者

    // 设置后继者
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    // 处理请求
    public abstract void handleRequest();
}

// 具体处理者1
class ConcreteHandler1 extends Handler {
    public void handleRequest() {
        if (successor != null) {
            successor.handleRequest(); // 转发请求
        }
    }
}

14. 命令模式（Command Pattern）

  • 核心思想：将请求封装成对象，从而使你可用不同的请求对客户进行参数化。
  • 适用场景：需要对请求排队、日志、撤销操作时。
java 复制代码 
// 命令接口
interface Command {
    void execute();
}

// 具体命令
class ConcreteCommand implements Command {
    private Receiver receiver; // 命令的接收者

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    public void execute() {
        receiver.action(); // 执行接收者的动作
    }
}

// 接收者
class Receiver {
    void action() {
        // 执行动作
    }
}

// 调用者
class Invoker {
    private Command command;

    // 设置命令
    public void setCommand(Command command) {
        this.command = command;
    }

    // 执行命令
    public void executeCommand() {
        command.execute();
    }
}

15. 解释器模式（Interpreter Pattern）

  • 核心思想：为给定的语言定义文法表示，并定义一个解释器来处理这个文法。
  • 适用场景：需要解释一种语言时。
java 复制代码 
// 表达式接口
interface Expression {
    int interpret();
}

// 数字表达式
class Number implements Expression {
    private int number;

    public Number(int number) {
        this.number = number;
    }

    public int interpret() {
        return number; // 返回数字的值
    }
}

// 加法表达式
class Plus implements Expression {
    private Expression leftOperand;
    private Expression rightOperand;

    public Plus(Expression left, Expression right) {
        this.leftOperand = left;
        this.rightOperand = right;
    }

    public int interpret() {
        return leftOperand.interpret() + rightOperand.interpret(); // 返回加法结果
    }
}

16. 迭代器模式（Iterator Pattern）

  • 核心思想：提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露其内部表示。
  • 适用场景：需要遍历聚合对象时。
java 复制代码 
// 迭代器接口
interface Iterator {
    boolean hasNext(); // 是否有下一个元素
    Object next(); // 获取下一个元素
}

// 聚合接口
interface Aggregate {
    Iterator createIterator(); // 创建迭代器
}

// 具体聚合类
class ConcreteAggregate implements Aggregate {
    private List<Object> items = new ArrayList<>();

    public Iterator createIterator() {
        return new ConcreteIterator(this); // 创建具体迭代器
    }
}

// 具体迭代器
class ConcreteIterator implements Iterator {
    private ConcreteAggregate aggregate;
    private int index;

    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

    public boolean hasNext() {
        return index < aggregate.items.size(); // 判断是否有下一个元素
    }

    public Object next() {
        return aggregate.items.get(index++); // 返回下一个元素
    }
}

17. 中介者模式（Mediator Pattern）

  • 核心思想：用一个中介对象来封装一系列对象的交互，使得对象之间不需要显式地相互引用。
  • 适用场景：需要减少对象之间的依赖时。
java 复制代码 
// 中介者接口
interface Mediator {
    void notify(Component sender, String event); // 通知方法
}

// 具体中介者
class ConcreteMediator implements Mediator {
    private Component1 component1;
    private Component2 component2;

    // 注册组件1
    public void registerComponent1(Component1 component) {
        this.component1 = component;
    }

    // 注册组件2
    public void registerComponent2(Component2 component) {
        this.component2 = component;
    }

    public void notify(Component sender, String event) {
        if (sender == component1 && event.equals("A")) {
            component2.doSomething(); // 组件1触发事件A，组件2响应
        } else if (sender == component2 && event.equals("B")) {
            component1.doSomething(); // 组件2触发事件B，组件1响应
        }
    }
}

// 组件抽象类
abstract class Component {
    protected Mediator mediator;

    public Component(Mediator mediator) {
        this.mediator = mediator;
    }
}

// 组件1
class Component1 extends Component {
    public Component1(Mediator mediator) {
        super(mediator);
    }

    public void doSomething() {
        mediator.notify(this, "A"); // 执行操作并通知中介者
    }
}

// 组件2
class Component2 extends Component {
    public Component2(Mediator mediator) {
        super(mediator);
    }

    public void doSomething() {
        mediator.notify(this, "B"); // 执行操作并通知中介者
    }
}

18. 备忘录模式（Memento Pattern）

  • 核心思想：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
  • 适用场景：需要保存和恢复对象状态时。
java 复制代码 
// 备忘录类
class Memento {
    private String state; // 状态

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state; // 获取状态
    }
}

// 原发器类
class Originator {
    private String state;

    public void setState(String state) {
        this.state = state; // 设置状态
    }

    public Memento saveStateToMemento() {
        return new Memento(state); // 保存状态到备忘录
    }

    public void getStateFromMemento(Memento memento) {
        state = memento.getState(); // 从备忘录恢复状态
    }
}

// 管理者类
class Caretaker {
    private List<Memento> mementoList = new ArrayList<>();

    public void add(Memento state) {
        mementoList.add(state); // 添加备忘录
    }

    public Memento get(int index) {
        return mementoList.get(index); // 获取备忘录
    }
}

19. 观察者模式（Observer Pattern）

  • 核心思想：定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都得到通知并被自动更新。
  • 适用场景：需要观察对象状态变化时。
java 复制代码 
// 观察者接口
interface Observer {
    void update(String state); // 更新方法
}

// 具体观察者
class ConcreteObserver implements Observer {
    public void update(String state) {
        // 处理更新
    }
}

// 主题类
class Subject {
    private List<Observer> observers = new ArrayList<>(); // 观察者列表
    private String state;

    public void attach(Observer observer) {
        observers.add(observer); // 添加观察者
    }

    public void setState(String state) {
        this.state = state;
        notifyAllObservers(); // 通知所有观察者
    }

    private void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update(state); // 更新观察者
        }
    }
}

20. 状态模式（State Pattern）

  • 核心思想：允许对象在内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
  • 适用场景：对象状态改变时行为也改变时。
java 复制代码 
// 状态接口
interface State {
    void handle(Context context); // 处理方法
}

// 具体状态A
class ConcreteStateA implements State {
    public void handle(Context context) {
        context.setState(new ConcreteStateB()); // 转换到状态B
    }
}

// 具体状态B
class ConcreteStateB implements State {
    public void handle(Context context) {
        context.setState(new ConcreteStateA()); // 转换到状态A
    }
}

// 上下文类
class Context {
    private State state;

    public Context(State state) {
        this.state = state; // 设置初始状态
    }

    public void setState(State state) {
        this.state = state; // 设置状态
    }

    public void request() {
        state.handle(this); // 请求处理
    }
}

21. 策略模式（Strategy Pattern）

  • 核心思想：定义一系列算法，把它们一个个封装起来，并且使它们可互相替换。
  • 适用场景：需要动态选择算法时。
java 复制代码 
// 策略接口
interface Strategy {
    void execute(); // 执行方法
}

// 具体策略A
class ConcreteStrategyA implements Strategy {
    public void execute() {
        // 策略A的实现
    }
}

// 具体策略B
class ConcreteStrategyB implements Strategy {
    public void execute() {
        // 策略B的实现
    }
}

// 上下文类
class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy; // 设置初始策略
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy; // 设置策略
    }

    public void executeStrategy() {
        strategy.execute(); // 执行策略
    }
}

22. 模板方法模式（Template Method Pattern）

  • 核心思想：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
  • 适用场景：多个类有相似算法时。
java 复制代码 
// 抽象类
abstract class AbstractClass {
    // 模板方法
    public final void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
    }

    // 基本操作1
    protected abstract void primitiveOperation1();

    // 基本操作2
    protected abstract void primitiveOperation2();
}

// 具体类
class ConcreteClass extends AbstractClass {
    protected void primitiveOperation1() {
        // 实现基本操作1
    }

    protected void primitiveOperation2() {
        // 实现基本操作2
    }
}

23. 访问者模式（Visitor Pattern）

  • 核心思想：将数据结构和作用于结构上的操作解耦，使得操作集合可独立变化。
  • 适用场景：需要对对象结构中的对象实施多种操作时。
java 复制代码 
// 访问者接口
interface Visitor {
    void visit(ElementA element);
    void visit(ElementB element);
}

// 元素接口
interface Element {
    void accept(Visitor visitor); // 接受访问者
}

// 具体元素A
class ElementA implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this); // 接受访问者
    }
}

// 具体元素B
class ElementB implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this); // 接受访问者
    }
}

// 具体访问者
class ConcreteVisitor implements Visitor {
    public void visit(ElementA element) {
        // 访问元素A的操作
    }

    public void visit(ElementB element) {
        // 访问元素B的操作
    }
}

总结

设计模式为我们提供了一种标准化的解决方案，可以应对软件开发中常见的问题。通过理解和应用这些模式，我们可以编写出更具可维护性、可扩展性和可重用性的代码。希望这篇博客能帮助你更好地理解和使用设计模式。每种模式都有其独特的应用场景，选择合适的模式可以显著提高代码质量和开发效率。

相关推荐
海特伟业15 小时前
隧道调频广播覆盖-隧道调频广播无线覆盖系统建设要点、难点分析与解决应对
运维·设计模式
sg_knight15 小时前
设计模式实战：享元模式（Flyweight）
python·设计模式·享元模式·flyweight
Swift社区17 小时前
AI 时代，ArkUI 的设计模式会改变吗？
人工智能·设计模式
数据中穿行18 小时前
访问者设计模式全方位深度解析
设计模式
宁雨桥18 小时前
前端设计模式面试题大全
前端·设计模式
数据中穿行19 小时前
迭代器设计模式全方位深度解析
设计模式
数据中穿行19 小时前
观察者设计模式全方位深度解析
设计模式
程序员Terry20 小时前
别老写重复代码了！模版方法模式一次讲透
java·设计模式
数据中穿行20 小时前
建造者模式全方位深度解析
设计模式
热门推荐
01GitHub 镜像站点02OpenClaw 使用和管理 MCP 完全指南03Qwen3.5 开源全解析：从 0.8B 到 397B，代际升级 + 全场景选型指南04本地部署 OpenClaw + DeepSeek-R1 完全指南05OpenClaw macOS 完整安装与本地模型配置教程（实战版）06OpenClaw 飞书机器人不回复消息？3 小时踩坑总结07得物前端部门，没了08UV安装并设置国内源09“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）10OpenClaw 连接飞书完整指南：插件安装、配置与踩坑记录