设计模式：编写高效、可维护的代码！

开篇语

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前序

在软件开发过程中，设计模式为我们提供了一套解决常见问题的标准化方法。设计模式不仅能帮助我们编写更具可读性的代码，还能提高代码的重用性、可扩展性和可维护性。Java中有很多经典的设计模式，它们在实际开发中得到了广泛应用。

今天，我们将探讨常见的设计模式，包括单例模式、工厂模式、观察者模式和策略模式等，分析它们的应用场景，并展示每种模式的实现方法。

前言

设计模式是软件开发中的一种标准化的解决方案，它们在多年的实践中积累了大量的经验，解决了我们在编程中经常遇到的各种问题。在面向对象编程中，设计模式帮助我们提高了代码的灵活性、扩展性和复用性。掌握设计模式不仅能让你写出更优雅的代码，还能提升你的编程能力。

今天，我们将讨论常见的四种设计模式：单例模式、工厂模式、观察者模式和策略模式。我们将分析每个模式的应用场景、优势与不足，并提供具体的实现代码。

第一部分：单例模式（Singleton Pattern）

1.1 单例模式简介

单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并且提供全局访问点。单例模式通常用于需要全局共享资源的场景，如数据库连接池、配置管理类等。

1.2 单例模式的应用场景

• 应用配置管理（例如，读取配置文件并保持单一实例）。
• 日志管理（例如，日志系统应该只有一个实例，避免创建多个日志对象）。
• 数据库连接池（为了避免频繁创建数据库连接实例）。

1.3 单例模式的实现

懒汉式单例模式：

public class Singleton {
    private static Singleton instance;

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

    // 提供一个静态方法，获取唯一实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();  // 延迟加载
        }
        return instance;
    }
}

解释：

• getInstance()方法使用了懒加载策略，只有在第一次调用时才创建实例。
• Singleton类的构造函数是私有的，防止外部直接实例化。

饿汉式单例模式：

public class Singleton {
    private static final Singleton instance = new Singleton();

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

    // 提供全局访问点
    public static Singleton getInstance() {
        return instance;
    }
}

解释：

• instance是静态常量，在类加载时就被创建，避免了延迟加载的复杂性。

第二部分：工厂模式（Factory Pattern）

2.1 工厂模式简介

工厂模式（Factory Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但由子类决定实例化哪一个类。工厂模式可以有效地隔离客户端和具体产品类的耦合关系，使得代码更具可扩展性。

2.2 工厂模式的应用场景

• 系统需要从多个类中选择一个类进行实例化时。
• 需要在运行时决定实例化哪一个类时。
• 在软件更新时，可能需要替换或扩展现有类而无需修改客户端代码。

2.3 工厂模式的实现

简单工厂模式：

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

// 具体产品类
public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("Product A");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("Product B");
    }
}

// 工厂类
public 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;
    }
}

解释：

• ProductFactory根据传入的type参数来决定返回哪个具体产品类的实例。

简单工厂的缺点： 如果增加新的产品类型，需要修改工厂方法。

改进：使用抽象工厂模式：

public interface Product {
    void doSomething();
}

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

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

public interface ProductFactory {
    Product createProduct();
}

public class ProductAFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

public class ProductBFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

第三部分：观察者模式（Observer Pattern）

3.1 观察者模式简介

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，使得一个对象的状态变化能够自动通知依赖它的多个对象。观察者模式通常用于事件驱动的场景，例如GUI应用程序中的按钮点击、系统中的事件处理等。

3.2 观察者模式的应用场景

• 事件驱动模型（例如，用户界面中的按钮点击）。
• 发布-订阅系统。
• 当一个对象的变化需要通知多个对象时。

3.3 观察者模式的实现

示例：

import java.util.ArrayList;
import java.util.List;

// 主题接口
public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体主题类
public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }

    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}

// 观察者接口
public interface Observer {
    void update(String state);
}

// 具体观察者类
public class ConcreteObserver implements Observer {
    private String name;

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

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

解释：

• ConcreteSubject 是具体的主题类，它管理观察者列表，并在状态变化时通知观察者。
• ConcreteObserver 是具体的观察者类，它接收主题的更新并作出响应。

第四部分：策略模式（Strategy Pattern）

4.1 策略模式简介

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

4.2 策略模式的应用场景

• 在一个系统中，需要在不同的情况下选择不同的算法或行为。
• 系统中有多个相似的行为，但行为的实现方式可能不同。

4.3 策略模式的实现

示例：

// 策略接口
public interface PaymentStrategy {
    void pay(int amount);
}

// 具体策略：支付宝支付
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Paying " + amount + " using Alipay.");
    }
}

// 具体策略：微信支付
public class WeChatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Paying " + amount + " using WeChat Pay.");
    }
}

// 上下文类
public class PaymentContext {
    private PaymentStrategy strategy;

    public PaymentContext(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

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

解释：

• PaymentStrategy 是策略接口，定义了支付的抽象方法。
• AlipayStrategy 和 WeChatPayStrategy 是具体的策略类，分别实现了不同的支付方式。
• PaymentContext 是上下文类，根据选择的策略执行不同的支付操作。

总结

设计模式为我们提供了一些常见问题的标准化解决方案，通过学习并应用这些设计模式，我们能够编写出更加高效、可维护的代码。单例模式、工厂模式、观察者模式和策略模式是常用的设计模式，它们各自有着不同的应用场景，能够帮助我们应对多线程、对象创建、事件驱动等多种编程需求。

掌握这些设计模式，能够使你写出的代码更加灵活、可扩展，并能在未来的项目中减少重复代码和提升系统的可维护性。

… …

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

… …

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。
⭐️若有疑问，就请评论留言告诉我叭。

版权声明：本文由作者原创，转载请注明出处，谢谢支持！