设计模式-单例桥接命令职责链
设计模式概述 - 单例 & 桥接 & 命令 & 职责链
单例模式简述
单例模式（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 {@Overridepublic void operationImpl() {System.out.println("ConcreteImplementorA: Operation implementation.");}
}// 具体实现类B
class ConcreteImplementorB implements Implementor {@Overridepublic 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);}@Overridepublic 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;}@Overridepublic void execute() {light.turnOn();}
}// 具体命令：关闭灯
class TurnOffLightCommand implements Command {private Light light;public TurnOffLightCommand(Light light) {this.light = light;}@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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 5handlerA.handleRequest(15); // Handler B handling request 15handlerA.handleRequest(25); // Handler C handling request 25handlerA.handleRequest(35); // Request 35 was not handled.}
}