设计模式大全：单例、工厂模式、策略模式、责任链模式

书院门前细致的苹果2026-02-08 21:35

设计模式是面向对象编程中一种解决特定问题的通用方案。它并不是直接可以用来复制的代码，而是解决问题的思路和结构框架。在这篇博客中，我们将详细讨论几种常见的设计模式：单例模式、工厂模式（简单工厂、工厂方法、抽象工厂）、策略模式和责任链模式。

1. 单例模式（Singleton Pattern）

定义

单例模式是一种创建型设计模式，旨在确保一个类只有一个实例，并提供一个全局的访问点来获取该实例。

优缺点

  • 优点：

    • 确保系统中该类只有一个实例。

    • 提供全局访问点，便于管理资源。

  • 缺点：

    • 不容易进行单元测试。

    • 难以扩展，如果需要增加多个实例就不适用了。

典型代码
饿汉式（Eager Singleton）：
复制代码 
public class Singleton {
    // 类加载时就创建实例
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}
懒汉式（Lazy Singleton）：
复制代码 
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;
    }
}
使用代码
复制代码 
public class Main {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2); // 输出 true
    }
}

2. 工厂模式（Factory Pattern）

工厂模式属于创建型设计模式，主要用于定义一个创建对象的接口，让子类决定实例化哪个类。工厂方法把类的实例化推迟到子类。

简单工厂模式（Simple Factory）
定义

简单工厂模式通过一个工厂类来创建不同类型的对象。工厂类根据传入的参数决定实例化哪一个产品类。

优缺点

  • 优点：

    • 简化了对象的创建过程。

    • 客户端不需要了解对象的创建过程，只需提供输入参数。

  • 缺点：

    • 增加新的产品时，需要修改工厂类，违背了开放-封闭原则。
典型代码
复制代码 
public class Product {
    public void show() {
        System.out.println("Product created!");
    }
}

public class SimpleFactory {
    public static Product createProduct() {
        return new Product();
    }
}
使用代码
复制代码 
public class Main {
    public static void main(String[] args) {
        Product product = SimpleFactory.createProduct();
        product.show();
    }
}
工厂方法模式（Factory Method）
定义

工厂方法模式通过定义一个接口来创建对象，由子类来决定实例化哪一个类。与简单工厂不同的是，工厂方法不由工厂类来控制实例化过程。

优缺点

  • 优点：

    • 增加新产品时，不需要修改已有代码，符合开放-封闭原则。

    • 每个具体工厂类负责创建一个具体产品，遵循单一职责原则。

  • 缺点：

    • 如果产品种类较多，工厂类数量也会增加，导致类的数量激增。
典型代码
复制代码 
// 产品接口
public interface Product {
    void show();
}

// 具体产品实现
public class ProductA implements Product {
    public void show() {
        System.out.println("ProductA created!");
    }
}

// 工厂接口
public interface Factory {
    Product createProduct();
}

// 具体工厂
public class FactoryA implements Factory {
    public Product createProduct() {
        return new ProductA();
    }
}
使用代码
复制代码 
public class Main {
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        Product product = factory.createProduct();
        product.show();
    }
}
抽象工厂模式（Abstract Factory）
定义

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而无需明确指定具体类。抽象工厂模式通过创建多个工厂来创建相关对象。

优缺点

  • 优点：

    • 提供一个接口来创建一系列相关的对象，客户端无需知道具体实现类。

    • 增加新的产品系列时，只需要增加具体工厂类即可，符合开放-封闭原则。

  • 缺点：

    • 工厂类会增加，系统复杂度上升。
典型代码
复制代码 
// 产品接口
public interface ProductA {
    void showA();
}

public interface ProductB {
    void showB();
}

// 具体产品
public class ProductA1 implements ProductA {
    public void showA() {
        System.out.println("ProductA1 created!");
    }
}

public class ProductB1 implements ProductB {
    public void showB() {
        System.out.println("ProductB1 created!");
    }
}

// 抽象工厂
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂
public class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA1();
    }
    public ProductB createProductB() {
        return new ProductB1();
    }
}
使用代码
复制代码 
public class Main {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();
        ProductA productA = factory.createProductA();
        ProductB productB = factory.createProductB();

        productA.showA();
        productB.showB();
    }
}

3. 策略模式（Strategy Pattern）

定义

策略模式是一种行为型设计模式，定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端。

优缺点

  • 优点：

    • 客户端可以根据需要选择算法，避免了大量的条件判断。

    • 新增算法时，客户端不需要修改，只需要新增策略类即可。

  • 缺点：

    • 可能会增加系统中的类数，过多的策略类会导致系统复杂度上升。
典型代码
复制代码 
// 策略接口
public interface Strategy {
    void execute();
}

// 具体策略
public class StrategyA implements Strategy {
    public void execute() {
        System.out.println("Executing StrategyA");
    }
}

public class StrategyB implements Strategy {
    public void execute() {
        System.out.println("Executing StrategyB");
    }
}

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

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}
使用代码
复制代码 
public class Main {
    public static void main(String[] args) {
        Strategy strategyA = new StrategyA();
        Context context = new Context(strategyA);
        context.executeStrategy();  // 执行 StrategyA

        Strategy strategyB = new StrategyB();
        context = new Context(strategyB);
        context.executeStrategy();  // 执行 StrategyB
    }
}

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

定义

责任链模式是一种行为型设计模式，旨在避免请求发送者与多个请求处理者之间的耦合关系。通过链式传递，能够将请求传递给不同的处理者，直到一个处理者处理该请求。

优缺点

  • 优点：

    • 请求发送者不需要知道哪个处理者处理了请求，解耦了发送者与处理者。

    • 可以动态地增加或删除处理者，符合开放-封闭原则。

  • 缺点：

    • 责任链的处理者如果设置不当，可能导致请求无法得到处理。

    • 需要确保责任链中所有处理者的顺序和逻辑。

典型代码
复制代码 
// 抽象处理者
public abstract class Handler {
    protected Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void handleRequest(int request);
}

// 具体处理者
public class ConcreteHandlerA extends Handler {
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("HandlerA handling request " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class ConcreteHandlerB extends Handler {
    public void handleRequest(int request) {
        if (request >= 10) {
            System.out.println("HandlerB handling request " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}
使用代码
复制代码 
public class Main {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNextHandler(handlerB);

        handlerA.handleRequest(5);  // HandlerA handling request 5
        handlerA.handleRequest(15); // HandlerB handling request 15
    }
}
相关推荐
BD_Marathon11 小时前
设计模式——依赖倒转原则
java·开发语言·设计模式
BD_Marathon11 小时前
设计模式——里氏替换原则
java·设计模式·里氏替换原则
jmxwzy11 小时前
设计模式总结
设计模式
J_liaty1 天前
23种设计模式一代理模式
设计模式·代理模式
苏渡苇1 天前
优雅应对异常，从“try-catch堆砌”到“设计驱动”
java·后端·设计模式·学习方法·责任链模式
短剑重铸之日1 天前
《设计模式》第十一篇：总结
java·后端·设计模式·总结
feasibility.1 天前
AI 编程助手进阶指南：从 Claude Code 到 OpenCode 的工程化经验总结
人工智能·经验分享·设计模式·自动化·agi·skills·opencode
BD_Marathon1 天前
七大设计原则介绍
设计模式
YigAin2 天前
Unity23种设计模式之 享元模式
设计模式·享元模式
热门推荐
01GitHub 镜像站点02Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services03openclaw配置教程（linux+局域网ollama）04Linux下V2Ray安装配置指南05OpenClaw Chrome扩展使用教程 - 浏览器中继控制06UV安装并设置国内源07Claude Code Skills 实用使用手册08一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示09使用 1panel面板 部署 php网站10让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南