【JAVA】Java高级：Java中的常用设计模式——设计模式的基本思想与应用场景

原创于 2024-11-24 10:00:00 发布 · 1k 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

JAVA 专栏收录该内容

126 篇文章

订阅专栏

在软件开发中，设计模式是一种被反复使用的解决特定问题的最佳实践。它们提供了一种标准化的方式来解决常见的设计问题，使得代码更具可读性、可维护性和可扩展性。特别是在Java开发中，设计模式的使用可以极大地提高代码的质量和开发效率。

设计模式不仅仅是代码的实现，它们还反映了软件设计的思维方式。通过理解和应用设计模式，开发者能够更好地应对复杂系统中的变化，提升团队的协作能力。

设计模式的分类

设计模式通常分为三大类：

创建型模式：关注对象的创建过程。
结构型模式：关注类和对象的组合。
行为型模式：关注对象之间的交互。

接下来，我们将逐一介绍这些模式及其应用场景，并通过具体的Java示例来阐明它们的使用。

一、创建型模式

创建型模式主要涉及如何创建对象。常见的创建型模式有：

单例模式（Singleton）
工厂模式（Factory）
抽象工厂模式（Abstract Factory）
建造者模式（Builder）
原型模式（Prototype）

1. 单例模式（Singleton）

基本思想：确保一个类只有一个实例，并提供一个全局访问点。

应用场景：需要控制对某个资源的访问，例如数据库连接、线程池等。

示例代码：

public class Singleton {
    // 私有静态实例
    private static Singleton instance;

    // 私有构造函数
    private Singleton() {}

    // 公共静态方法，提供全局访问点
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

代码解释：

private static Singleton instance;：存储唯一实例。
private Singleton()：私有构造函数，防止外部实例化。
public static Singleton getInstance()：提供全局访问点，懒加载实例。

2. 工厂模式（Factory）

基本思想：定义一个接口用于创建对象，但让子类决定实例化哪一个类。

应用场景：当系统需要独立于产品的创建、组合和表示时。

示例代码：

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

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

// 工厂类
class ProductFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

代码解释：

Product接口定义了产品的行为。
ConcreteProductA和ConcreteProductB是具体的产品实现。
ProductFactory类根据传入的类型创建相应的产品。

二、结构型模式

结构型模式关注类和对象的组合，常见的结构型模式有：

适配器模式（Adapter）
装饰者模式（Decorator）
代理模式（Proxy）
外观模式（Facade）
组合模式（Composite）

1. 适配器模式（Adapter）

基本思想：将一个类的接口转换成客户端所期望的另一个接口，使得原本由于接口不兼容而无法一起工作的类可以一起工作。

应用场景：当你想使用一些现有的类，但它们的接口不符合你的需求时。

示例代码：

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

// 适配者类
class Adaptee {
    public void specificRequest() {
        System.out.println("Specific request");
    }
}

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

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

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

代码解释：

Target是客户端所期望的接口。
Adaptee是现有的类，接口不兼容。
Adapter实现了Target接口，并通过组合Adaptee来适配其方法。

三、行为型模式

行为型模式关注对象之间的交互，常见的行为型模式有：

策略模式（Strategy）
观察者模式（Observer）
命令模式（Command）
状态模式（State）
迭代器模式（Iterator）

1. 策略模式（Strategy）

基本思想：定义一系列算法，将每一个算法封装起来，并使它们可以互换。

应用场景：需要在运行时选择算法时，例如排序策略。

示例代码：

// 策略接口
interface Strategy {
    int doOperation(int num1, int num2);
}

// 具体策略
class OperationAdd implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

class OperationSubtract implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

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

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

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

代码解释：