深入理解常见的设计模式

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

. 工厂模式（Factory Pattern）

工厂模式用于创建对象，而不需要将对象的创建逻辑暴露给客户端。在项目中，可以使用工厂模式来根据不同的条件创建不同的对象实例。例如，如果有一个产品管理系统，可以使用工厂模式根据产品类型来创建不同的产品对象，而客户端只需要知道如何使用产品对象，而不需要知道如何创建它们。

应用场景：

图形用户界面工具包（GUI Toolkit）
抽象工厂模式可用于创建产品族

示例代码：

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
}

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

3. 观察者模式（Observer Pattern）

观察者模式用于定义对象之间的一对多依赖关系，当一个对象的状态发生变化时，其相关依赖对象都会收到通知并自动更新。在项目中，可以使用观察者模式来实现事件驱动的编程模型。例如，在一个社交媒体应用中，可以使用观察者模式来实现用户之间的关注关系，当被关注用户发布新的内容时，所有关注者都会收到通知。

应用场景：

GUI 中的事件处理
发布-订阅系统

示例代码：

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

public class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}

public class ConcreteObserver extends Observer {
    public ConcreteObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Observer updated");
    }
}

4. 策略模式（Strategy Pattern）

策略模式用于定义一系列算法，并将每个算法封装到单独的类中，使它们可以互相替换。在项目中，可以使用策略模式来实现不同的算法族，根据不同的情况选择合适的算法。例如，在电商平台中，可以使用策略模式来实现不同的支付方式，让用户可以根据自己的喜好选择支付方式。

应用场景：

文件压缩/解压缩
排序算法

示例代码：

public interface CompressionStrategy {
    public void compressFile(String fileName);
}

public class ZipCompressionStrategy implements CompressionStrategy {
    @Override
    public void compressFile(String fileName) {
        System.out.println("Compressing using Zip strategy");
    }
}

public class RarCompressionStrategy implements CompressionStrategy {
    @Override
    public void compressFile(String fileName) {
        System.out.println("Compressing using RAR strategy");
    }
}

public class Compressor {
    private CompressionStrategy compressionStrategy;

    public Compressor(CompressionStrategy compressionStrategy) {
        this.compressionStrategy = compressionStrategy;
    }

    public void compressFile(String fileName) {
        compressionStrategy.compressFile(fileName);
    }
}

5、装饰器模式（Decorator Pattern）

装饰器模式是一种结构型设计模式，它允许你在不修改原始类的情况下，动态地给对象添加额外的功能。这种模式通过将对象包装在装饰器类的对象中来实现，使得可以在运行时动态地添加或修改对象的行为。

核心概念

在装饰器模式中，有以下几个核心角色：

Component（组件）： 定义了一个对象接口，可以动态地给这些对象添加新的职责。
ConcreteComponent（具体组件）： 实现了 Component 接口，并定义了需要被装饰的对象。
Decorator（装饰器）： 持有一个指向 Component 对象的引用，并实现了 Component 接口，它的接口与 Component 一致，同时也可以包含一些附加的行为。
ConcreteDecorator（具体装饰器）： 扩展了 Decorator 类，并添加了一些额外的功能。

应用场景

装饰器模式适用于以下情况：

当需要动态地给对象添加功能，而且这些功能可以在运行时移除时。
当使用继承来扩展对象的功能不切实际或不灵活时。
当需要透明且动态地扩展对象的功能，而不影响其接口时。

在项目中的应用示例

在一个文件处理应用中，可以使用装饰器模式来给文件流添加缓冲功能，而不需要修改文件流的原始实现。

Component：File

public interface File {
    void read();
    void write(String data);
}

ConcreteComponent：FileStream

public class FileStream implements File {
    @Override
    public void read() {
        System.out.println("Reading file...");
        // 读取文件的实现
    }

    @Override
    public void write(String data) {
        System.out.println("Writing to file: " + data);
        // 写入文件的实现
    }
}

Decorator：FileDecorator

public abstract class FileDecorator implements File {
    protected File file;

    public FileDecorator(File file) {
        this.file = file;
    }

    @Override
    public void read() {
        file.read();
    }

    @Override
    public void write(String data) {
        file.write(data);
    }
}

ConcreteDecorator：BufferedFile

public class BufferedFile extends FileDecorator {
    public BufferedFile(File file) {
        super(file);
    }

    @Override
    public void read() {
        System.out.println("Adding buffering functionality...");
        super.read();
        // 添加缓冲功能的实现
    }

    @Override
    public void write(String data) {
        System.out.println("Adding buffering functionality...");
        super.write(data);
        // 添加缓冲功能的实现
    }
}

使用示例

public class Main {
    public static void main(String[] args) {
        File file = new FileStream();
        file = new BufferedFile(file); // 添加缓冲功能
        file.read();
        file.write("Some data");
    }
}

装饰器模式是一种灵活且强大的设计模式，它允许你通过组合对象来动态地添加新的功能，而无需修改现有代码。通过保持接口的一致性，装饰器模式使得客户端可以以透明的方式使用装饰后的对象。这种模式在需要动态地扩展对象功能时非常有用，并且有助于遵循开闭原则。