设计模式概述 - 单例 & 桥接 & 命令 & 职责链

单例模式简述

单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。单例模式通常用于需要全局控制的资源，如配置管理、日志管理等。

角色

• 单例类（Singleton）：负责创建和管理自己的唯一实例，并提供访问方法。

优点

• 节省内存：由于只创建一个实例，可以减少内存开销。
• 全局访问：提供了一个全局访问点，方便管理和使用。
• 控制实例数量：确保只有一个实例存在，避免了资源的浪费。

缺点

• 隐藏类的设计：可能导致类的设计不够灵活，增加了系统的耦合性。
• 多线程问题：在多线程环境下，如果没有正确实现，可能导致多个实例的创建。
• 难以测试：可能会使单元测试变得复杂，因为它引入了全局状态。

示例代码

// 单例类
public class Singleton {
    // 使用 volatile 关键字确保多线程环境下的可见性
    private static volatile Singleton instance;

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

    // 双重检查锁定的获取实例方法
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    // 示例方法
    public void someMethod() {
        System.out.println("Singleton method called.");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.someMethod(); // 调用单例方法
    }
}

桥接模式简述

桥接模式（Bridge Pattern）是一种结构型设计模式，它通过将抽象部分与实现部分分离，使它们可以独立变化。桥接模式通常用于需要在多个维度上扩展的系统中，可以减少类的数量，提高系统的灵活性和可扩展性。

角色

• 抽象类（Abstraction）：定义了抽象部分的接口，并持有一个实现部分的引用。
• 扩展抽象类（RefinedAbstraction）：实现抽象类的具体类，扩展抽象部分的功能。
• 实现接口（Implementor）：定义实现部分的接口。
• 具体实现类（ConcreteImplementor）：实现实现接口的具体类。

优点

• 解耦：将抽象和实现分离，降低了系统的耦合度。
• 灵活性：可以独立地扩展抽象和实现部分，增加了系统的灵活性。
• 易于维护：由于各部分职责清晰，系统更易于维护和扩展。

缺点

• 增加复杂性：可能会增加系统的复杂性，特别是在简单场景下。
• 类的数量增加：可能导致类的数量增加，增加了系统的管理难度。

示例代码

// 实现接口
interface Implementor {
    void operationImpl();
}

// 具体实现类A
class ConcreteImplementorA implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("ConcreteImplementorA: Operation implementation.");
    }
}

// 具体实现类B
class ConcreteImplementorB implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("ConcreteImplementorB: Operation implementation.");
    }
}

// 抽象类
abstract class Abstraction {
    protected Implementor implementor;

    protected Abstraction(Implementor implementor) {
        this.implementor = implementor;
    }

    public abstract void operation();
}

// 扩展抽象类
class RefinedAbstraction extends Abstraction {
    public RefinedAbstraction(Implementor implementor) {
        super(implementor);
    }

    @Override
    public void operation() {
        System.out.print("RefinedAbstraction: ");
        implementor.operationImpl();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Implementor implementorA = new ConcreteImplementorA();
        Abstraction abstractionA = new RefinedAbstraction(implementorA);
        abstractionA.operation();

        Implementor implementorB = new ConcreteImplementorB();
        Abstraction abstractionB = new RefinedAbstraction(implementorB);
        abstractionB.operation();
    }
}

命令模式简述

命令模式（Command Pattern）是一种行为型设计模式，它将请求封装为对象，从而使您可以用不同的请求对客户进行参数化、排队或记录请求日志，并支持可撤销的操作。命令模式使得调用者与接收者之间的解耦，提高了系统的灵活性和可扩展性。

角色

• 命令接口（Command）：定义执行操作的接口。
• 具体命令（ConcreteCommand）：实现命令接口，定义与接收者之间的绑定关系，并调用接收者的方法。
• 接收者（Receiver）：知道如何实施与执行请求相关的操作。
• 调用者（Invoker）：要求执行命令的对象。

优点

• 解耦：将请求的发送者与接收者解耦，降低了系统的耦合度。
• 可扩展性：可以轻松添加新的命令类，扩展系统功能。
• 支持撤销和重做：可以通过维护命令的历史记录，支持撤销和重做操作。

缺点

• 类的数量增加：每个命令都需要一个具体的命令类，可能导致类的数量增加。
• 复杂性：在某些情况下，可能使系统变得更加复杂，尤其是在命令数量较多时。

示例代码

// 命令接口
interface Command {
    void execute();
}

// 接收者
class Light {
    public void turnOn() {
        System.out.println("The light is ON");
    }

    public void turnOff() {
        System.out.println("The light is OFF");
    }
}

// 具体命令：打开灯
class TurnOnLightCommand implements Command {
    private Light light;

    public TurnOnLightCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }
}

// 具体命令：关闭灯
class TurnOffLightCommand implements Command {
    private Light light;

    public TurnOffLightCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOff();
    }
}

// 调用者
class RemoteControl {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void pressButton() {
        command.execute();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Light light = new Light();
        Command turnOn = new TurnOnLightCommand(light);
        Command turnOff = new TurnOffLightCommand(light);

        RemoteControl remote = new RemoteControl();

        remote.setCommand(turnOn);
        remote.pressButton(); // 输出 "The light is ON"

        remote.setCommand(turnOff);
        remote.pressButton(); // 输出 "The light is OFF"
    }
}

职责链模式简述

职责链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许将请求的发送者与接收者解耦，使多个对象都有机会处理该请求。请求沿着处理链传递，直到有一个对象处理它为止。职责链模式常用于事件处理、日志记录等场景。

角色

• 处理者（Handler）：定义处理请求的接口，并可以设置下一个处理者。
• 具体处理者（ConcreteHandler）：实现处理请求的具体逻辑，并决定是否处理请求或将其传递给下一个处理者。
• 客户端（Client）：构建职责链并发起请求。

优点

• 解耦：请求的发送者与接收者之间解耦，增加了系统的灵活性。
• 动态处理：可以在运行时动态地改变处理链的结构。
• 可扩展性：可以轻松添加新的处理者而不影响现有代码。

缺点

• 性能开销：在某些情况下，职责链的处理可能导致性能开销。
• 调试困难：调试时可能不容易追踪请求的处理路径。

示例代码

// 处理者接口
abstract class Handler {
    protected Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void handleRequest(int request);
}

// 具体处理者A
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("Handler A handling request " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 具体处理者B
class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request < 20) {
            System.out.println("Handler B handling request " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 具体处理者C
class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request < 30) {
            System.out.println("Handler C handling request " + request);
        } else {
            System.out.println("Request " + request + " was not handled.");
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();

        handlerA.setNextHandler(handlerB);
        handlerB.setNextHandler(handlerC);

        // 测试请求
        handlerA.handleRequest(5);   // Handler A handling request 5
        handlerA.handleRequest(15);  // Handler B handling request 15
        handlerA.handleRequest(25);  // Handler C handling request 25
        handlerA.handleRequest(35);  // Request 35 was not handled.
    }
}