Java设计模式

设计模式是解决软件开发中常见问题的通用方案，能提高代码的可维护性、可扩展性和可重用性。

1. 单例模式 (Singleton Pattern)

• 场景：确保某个类只有一个实例，并且提供全局访问点。常见于数据库连接池、日志管理器、配置管理器等场景。

在 Java 中，实现单例模式有多种方式，常见的包括：

懒汉式（Lazy Initialization）：在第一次调用时才创建实例。

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

饿汉式（Eager Initialization）：在类加载时就创建实例。

public class EagerSingleton {
    // 在类加载时就实例化对象，保证了单例的唯一性
    private static final EagerSingleton instance = new EagerSingleton();
    
    // 私有化构造函数，避免外部实例化
    private EagerSingleton() {}
    
    // 提供公有的静态方法获取实例
    public static EagerSingleton getInstance() {
        return instance;
    }
}

双重检查锁（Double-Checked Locking）：通过双重检查加锁来确保只有一个实例被创建,多线程环境中高效地确保单例对象的唯一性，同时避免了不必要的同步开销。

public class DoubleCheckedSingleton {
    // 声明一个静态的 volatile 实例变量，确保其线程安全
    private static volatile DoubleCheckedSingleton instance;
 
    // 私有构造函数，防止外部直接实例化
    private DoubleCheckedSingleton() {}

    // 获取单例实例的公共方法
    public static DoubleCheckedSingleton getInstance() {
        // 第一重检查：如果实例已经创建，则直接返回，不进入同步块
        if (instance == null) {
            // 加锁，确保多线程环境下只有一个线程能初始化实例
            synchronized (DoubleCheckedSingleton.class) {
                // 第二重检查：再检查一次实例是否为 null，防止多个线程同时创建实例
                if (instance == null) {
                    // 创建唯一实例
                    instance = new DoubleCheckedSingleton();
                }
            }
        }
        // 返回唯一实例
        return instance;
    }
}

静态内部类（Static Inner Class）：利用类加载机制保证线程安全并且延迟加载。

（延迟加载，线程安全，性能提升）

// 定义了一个名为StaticInnerClassSingleton的类，用于实现单例模式
public class StaticInnerClassSingleton {

    // 私有化构造方法，防止外部通过new关键字直接创建实例
    private StaticInnerClassSingleton() {}

    // 定义一个私有的静态内部类SingletonHolder
    // 静态内部类只有在被调用时才会被加载到JVM中，从而实现了延迟加载的效果
    private static class SingletonHolder {
        // 在静态内部类中定义一个静态的final的实例，并将其初始化为StaticInnerClassSingleton的一个新实例
        // 由于这个实例是静态的，它将在SingletonHolder类首次被加载时初始化，并且只会初始化一次
        // 这种方式既保证了线程安全（类加载是线程安全的），又实现了延迟加载（只有在getInstance方法被调用时才会加载SingletonHolder类）
        private static final StaticInnerClassSingleton instance = new StaticInnerClassSingleton();
    }

    // 提供一个公共的静态方法getInstance来获取单例实例
    // 当这个方法被首次调用时，它会触发SingletonHolder类的加载，从而创建StaticInnerClassSingleton的唯一实例
    // 由于instance是静态的并且是final的，它一旦被初始化就不会再改变，从而保证了单例模式的实现
    public static StaticInnerClassSingleton getInstance() {
        // 返回静态内部类中定义的实例
        return SingletonHolder.instance;
    }
}

2. 工厂模式 (Factory Pattern)

 工厂模式提供了一种将对象的实例化过程封装在工厂类中的方式。通过使用工厂模式，可以将对象的创建与使用代码分离，提供一种统一的接口来创建不同类型的对象。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

简单工厂模式（Simple Factory Pattern）：提供一个工厂类来创建不同类型的对象，根据输入的参数决定具体创建哪个类的实例。

工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，由子类决定实例化哪个类。

抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体类。

工厂方法模式只考虑生产同等级的产品，抽象工厂可以处理多等级产品的生产

抽象工厂可以是在工厂模式只有产品族的单维度（只生产咖啡或饼干）的产品生产上，添加了产品等级的生产（咖啡是意大利咖啡和美式咖啡，饼干是美式饼干和意大利饼干）；

原本一个工厂生成一种产品，现在生成一个商品族；

拥有一个超级工厂，下有具体工厂美国产品工厂和意大利产品工厂；

3.观察者模式 (Observer Pattern)

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

观察者模式包含以下角色：

主题（Subject）：被观察的对象，维护一个观察者列表，提供添加、删除和通知观察者的方法。
观察者（Observer）：观察主题对象的状态变化，实现 Update 方法来更新自己的状态。
具体主题（ConcreteSubject）：继承自抽象主题，实现具体业务逻辑。
具体观察者（ConcreteObserver）：继承自抽象观察者，实现具体业务逻辑。
使用观察者模式可以使得系统更加灵活、可扩展，减少各个模块之间的耦合度。

4.策略模式 (Strategy Pattern)

策略模式是一种行为型设计模式，用于定义一系列算法，将每个算法封装起来，并使它们可以互换。策略模式让算法的变化独立于使用算法的客户，从而提高系统的灵活性。

应该是对于同一个业务功能，在不同的场景需求下提供不同的实现逻辑，来达到动态切换业务算法，满足不同场景的目的

定义一系列算法，并将每个算法封装起来，使它们可以互换。客户端可以选择所需的算法。常用于支付方式、排序方式等。

• Context: 环境类
• Strategy: 抽象策略类
• ConcreteStrategy: 具体策略类

优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。

5. 装饰者模式 (Decorator Pattern)

• 使用场景：咖啡店系统中，可以通过装饰者模式添加不同的配料，如牛奶、糖等，每个装饰器都可以独立扩展功能。

• 动态地给一个对象添加一些额外的功能，而不影响其他对象。适用于GUI组件的功能扩展，或者数据流的处理链。

6.命令模式 (Command Pattern)

• 场景：将请求封装为一个对象，以便使用不同的请求、队列或日志请求。可以用于实现宏命令、撤销操作等。

• 使用场景：遥控器控制设备、Undo/Redo操作等。

7. 适配器模式 (Adapter Pattern)

• 场景：将一个类的接口转换成客户期望的另一个接口。常见于不同接口的兼容处理，比如老旧系统与新系统的对接。

• 使用场景：当你需要使用一个现有的类，但它的接口与预期不符时。比如通过适配器使旧版接口兼容新版系统接口。