Java实现的21种设计模式代码精华

最新推荐文章于 2025-08-12 13:27:13 发布

原创最新推荐文章于 2025-08-12 13:27:13 发布 · 820 阅读

本内容遵循CC 4.0 BY-SA版权协议

简介：设计模式是软件开发中解决常见编程问题的有效方法，这个资源包”Java实现的21种设计模式代码精华”提供了21种经典设计模式的Java实现版本，并附有详细讲解。涵盖了单例模式、工厂模式、抽象工厂模式等多种模式，旨在帮助开发者提高代码质量，增强可维护性和扩展性。
21种设计模式java实现版本代码.rar

1. Java设计模式概述

设计模式是软件工程中的一种重要概念，它是一套被广泛认可的最佳实践，用于解决软件开发过程中重复遇到的问题。设计模式为软件设计和开发提供了一种可重用、可维护的代码结构，帮助开发者以更为标准和高效的方式组织代码，从而提高代码的可读性和可扩展性。

在Java编程语言中，设计模式的应用尤为广泛。由于Java是一种面向对象的编程语言，它天然适合实现各种设计模式，特别是那些强调对象间关系和通信的设计模式。设计模式不仅能够在大型企业级项目中发挥巨大作用，也同样适用于小型应用和快速开发的项目。

本章节首先概述设计模式的定义和分类，随后将在后续章节中深入探讨每一种设计模式的实现细节以及在Java中的应用。通过案例分析和代码示例，我们将揭示设计模式在实际开发中的强大功能和重要性。

2.1 单例模式的实现

2.1.1 单例模式基础理论

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保一个类只有一个实例，并且提供一个全局访问点来获取该实例。单例模式通常用于管理配置信息、数据库连接等场景，确保整个应用程序中只存在一个共享的实例。

单例模式的核心思想在于将类的构造函数设为私有，以避免外部代码通过new操作符创建类的实例。同时，提供一个静态方法返回这个唯一的实例。如果实例不存在，则在获取实例时创建它；如果已经存在，则直接返回已创建的实例。

2.1.2 单例模式的线程安全实现

在线程环境中，单例模式的实现需要特别注意线程安全问题。如果不进行适当的处理，可能会导致多线程环境下创建多个实例。以下是一个线程安全的单例模式实现方法：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

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

在上述代码中，首先检查实例是否已经创建。如果没有，那么进入同步块，再次检查实例是否为null（这称为“双重检查锁定”）。如果实例仍然为null，则创建一个新的实例。通过这种方式，确保了多线程环境下的线程安全。

2.1.3 饿汉式与懒汉式单例对比

单例模式有两种实现方式：饿汉式和懒汉式。两者的主要区别在于实例的创建时机不同。

饿汉式：类加载时就初始化，不管是否使用。这种方式简单，但在类加载较重的情况下会浪费资源。
懒汉式：当第一次使用类时才初始化。这种方式可以节省资源，但需要考虑线程安全问题。

在选择使用饿汉式还是懒汉式时，需要根据实际情况进行权衡。如果单例对象的创建过程非常耗时且资源消耗大，而应用程序的生命周期中单例对象通常会被使用，那么饿汉式是更好的选择。如果单例对象的创建过程轻量且应用程序并不总是在启动时就需要单例对象，懒汉式可能更加合适。

在上述的线程安全实现示例中，我们使用的是懒汉式单例，并且在创建实例前进行了双重检查锁定，这样既保证了线程安全又避免了不必要的同步开销。

3. 结构型设计模式的实现

3.1 适配器模式与装饰器模式的实现

3.1.1 适配器模式的工作原理

适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户期望的另一个接口，这样原本接口不兼容的类就可以一起工作。适配器模式涉及三个角色：目标接口（Target）、需要被适配的类（Adaptee），以及具体的适配器（Adapter）。适配器实现了目标接口，并封装了一个Adaptee的实例，通过调用Adaptee的接口来实现Target接口。

以下是Java语言中实现适配器模式的一个简单示例：

// 目标接口
public interface Target {
    void request();
}

// 被适配类
public class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee specificRequest method.");
    }
}

// 适配器类
public class Adapter implements Target {
    private Adaptee adaptee = new Adaptee();

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Target target = new Adapter();
        target.request();
    }
}

适配器模式在实际开发中非常有用，比如在整合第三方库或者旧系统的接口时，我们可能需要适配它们的接口到我们当前的系统结构中。通过适配器模式，我们可以保持接口的一致性，而不需要修改现有的系统代码。

3.1.2 装饰器模式的扩展应用

装饰器模式也是一种结构型设计模式，它可以动态地给一个对象添加一些额外的职责。装饰器提供与具体组件相同的接口，因此可以在不改变该对象的情况下给它添加额外的功能。装饰器模式通常包含四个角色：组件（Component）、具体组件（ConcreteComponent）、装饰器（Decorator）和具体装饰器（ConcreteDecorator）。

下面是一个简单的装饰器模式实现示例：

// 组件接口
public interface Component {
    void operation();
}

// 具体组件
public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("ConcreteComponent operation.");
    }
}

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

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

    public void operation() {
        component.operation();
    }
}

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

    public void addedBehavior() {
        System.out.println("Added Behavior.");
    }

    @Override
    public void operation() {
        super.operation();
        addedBehavior();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        component = new ConcreteDecorator(component);
        component.operation();
    }
}

在实际开发中，装饰器模式常用于给对象添加额外行为，比如日志记录、权限检查、事务管理等。通过装饰器模式，我们可以在不改变原有对象结构的基础上，增强对象的功能。

3.1.3 两模式在实际开发中的比较

适配器模式和装饰器模式在某些情况下看起来非常相似，但它们的应用目的不同。适配器模式主要用于解决接口不兼容的问题，而装饰器模式则是为了增加额外的功能。下面是两者的比较：

目的不同：适配器模式是为了让两个不兼容的接口可以一起工作，而装饰器模式是为增加额外功能。
结构不同：适配器模式使用了组合或继承的方式，而装饰器模式使用了组合的方式。
使用时机不同：适配器模式通常是预先设计好的，用于整合已有的系统；装饰器模式则是在系统的演化过程中，根据需要动态地给对象添加新功能。

理解这两种模式的不同点，可以帮助开发者在不同的情境中选择最合适的模式来解决问题。

4. 行为型设计模式的实现

在软件工程领域，行为型设计模式主要关注对象之间的职责分配、交互、以及对象间通信的控制。它们解决的是对象间的通信问题，并指导对象如何协作，以实现更复杂的行为。在这一章中，我们将深入探讨责任链模式、命令模式、解释器模式、状态模式、策略模式、模板方法模式、访问者模式和备忘录模式这八种行为型设计模式的实现细节和应用场景。

4.1 责任链模式、命令模式与解释器模式的实现

行为型模式中的责任链模式、命令模式和解释器模式提供了不同的通信机制和执行流程。它们在不同的上下文中具有独特的应用价值和实现方法。

4.1.1 责任链模式的链式处理

责任链模式是一种行为设计模式，它允许将请求沿着处理者链传递，直到有一个处理者处理该请求为止。这种方式有助于解耦发送者和接收者，使得多个对象都有机会处理请求。

实现要点：
- 定义处理器接口 ：所有具体的处理器都需要实现同一个接口。
- 构建链 ：每个处理器知道下一个处理器是谁。
- 请求的传递 ：请求从链的头部开始传递，直到被处理。

// 示例代码：责任链模式实现
public abstract class Handler {
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(Request request);
}

public class ConcreteHandler1 extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getStatus() == Status.NOT_HANDLED) {
            System.out.println("Handler1 handled request");
            request.setStatus(Status.HANDLED);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 使用责任链模式
Handler handler1 = new ConcreteHandler1();
Handler handler2 = new ConcreteHandler2();
handler1.setSuccessor(handler2);
Request request = new Request(Status.NOT_HANDLED);
handler1.handleRequest(request);

参数说明：
- Handler ：处理器接口，定义处理请求的方法。
- ConcreteHandler1 ：具体处理器，根据请求状态决定是否处理。
- Request ：请求类，包含请求状态。
- Status ：请求状态枚举，区分请求是否已被处理。

责任链模式通过将请求在责任链中传递来实现对请求的处理，从而使得请求者和处理者解耦。

4.1.2 命令模式的实际应用

命令模式将请求封装为对象，从而使用户可以将不同请求参数化、排队或记录请求日志，也可以支持可撤销的操作。

实现要点：
- 定义命令接口 ：所有命令对象都实现该接口。
- 创建接收者类 ：命令对象调用以执行请求。
- 创建具体命令类 ：在执行时，它会调用接收者的操作。
- 客户端 ：创建一个具体命令对象并设定它的接收者。

// 示例代码：命令模式实现
public interface Command {
    void execute();
}

public class ConcreteCommand implements Command {
    private Receiver receiver;

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

    @Override
    public void execute() {
        receiver.action();
    }
}

public class Receiver {
    public void action() {
        System.out.println("Receiver action");
    }
}

// 客户端代码
Command command = new ConcreteCommand(new Receiver());
command.execute();

参数说明：
- Command ：命令接口，定义执行方法。
- ConcreteCommand ：具体命令类，执行具体命令时调用接收者的方法。
- Receiver ：接收者类，具体执行动作。

命令模式通过引入命令对象，将请求封装为对象，可以灵活地控制命令的排队执行、撤销执行等。

4.1.3 解释器模式的场景分析

解释器模式为特定类型的问题定义一个解释器。当你需要一个语言解释器时，这个模式就显得很有用。它为语言的每种文法定义一个解释器，并在该文法中使用的类的组合中表示该语言的句子。

实现要点：
- 定义抽象表达式 ：声明一个抽象的解释操作。
- 定义终结符表达式 ：实现与文法中的终结符相关的解释操作。
- 定义非终结符表达式 ：存储子表达式，为文法中的非终结符实现解释操作。
- 上下文类 ：包含解释器之外的全局信息。
- 客户端 ：构建（或被给定）表示文法特定的解释器的表达式。

// 示例代码：解释器模式实现
public interface Expression {
    boolean interpreter(String context);
}

public class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    @Override
    public boolean interpreter(String context) {
        return context.contains(data);
    }
}

public class OrExpression implements Expression {
    private Expression expr1;
    private Expression expr2;

    public OrExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    @Override
    public boolean interpreter(String context) {
        return expr1.interpreter(context) || expr2.interpreter(context);
    }
}

// 客户端代码
String context = "this is a test";
Expression isJava = new TerminalExpression("java");
Expression isPython = new TerminalExpression("python");
Expression isJavaOrPython = new OrExpression(isJava, isPython);
boolean result = isJavaOrPython.interpreter(context);
System.out.println(result);

参数说明：
- Expression ：抽象表达式接口，声明解释操作。
- TerminalExpression ：终结符表达式类，用于在文法中的终结符上实现解释操作。
- OrExpression ：非终结符表达式类，用以解释表达式，这里是一个”或”操作。
- 上下文 context ：表示待解释的字符串。

解释器模式适合用来构建简单解释器，但当文法过于复杂时，可能会带来性能问题。

5. 设计模式综合实践案例分析

在前几章中，我们详细探讨了设计模式的理论知识与实现方式。现在，让我们将这些知识应用到实际的项目中，看看设计模式是如何在企业级应用以及小型项目中发挥作用的。

5.1 设计模式在企业级应用中的综合运用

企业级应用通常需要处理复杂的业务逻辑，需要保证系统的高可用性、可扩展性和安全性。设计模式可以帮助我们更好地实现这些需求。

5.1.1 实际案例分析：服务端架构设计

在服务端架构设计中，我们通常会遇到需要将请求分发到不同服务处理的情况。这里我们可以使用策略模式来动态选择不同的处理策略，或者使用责任链模式来依次处理请求。

// 策略模式的简单实现
public interface Strategy {
    void handleRequest(Request request);
}

public class ConcreteStrategyA implements Strategy {
    @Override
    public void handleRequest(Request request) {
        // 处理请求的逻辑A
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void handleRequest(Request request) {
        // 处理请求的逻辑B
    }
}

// 使用策略模式的上下文
public class Context {
    private Strategy strategy;

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

    public void executeStrategy(Request request) {
        strategy.handleRequest(request);
    }
}

5.1.2 设计模式的组合使用

在实际开发中，我们往往会发现单一的设计模式并不能完全解决所有的设计问题。这时，我们可以通过组合不同的设计模式来达到最佳的设计效果。例如，我们可以同时使用工厂模式和单例模式，来保证对象的唯一创建和全局访问。

5.1.3 代码重构与性能优化实例

在维护和优化现有系统时，设计模式可以帮助我们识别出那些可以进行重构的部分，以及如何重构来提高性能。

// 原始代码片段，包含多处重复的逻辑
public class OrderService {
    public void processOrder(Order order) {
        // 大量的业务逻辑处理
    }
}

// 使用模板方法模式重构后的代码
public abstract class AbstractOrderService {
    public final void processOrder(Order order) {
        // 标准化流程，如检查库存、扣减库存等
        concreteProcessOrder(order);
    }

    protected abstract void concreteProcessOrder(Order order);
}

public class ConcreteOrderService extends AbstractOrderService {
    @Override
    protected void concreteProcessOrder(Order order) {
        // 具体的业务逻辑处理
    }
}