设计模式----链式设计
设计模式中使用链式设计的有两个，装饰模式和职责链模式
装饰模式
定义：
动态的给一个对象添加一些额外的职责
结构：
它包括四部分
Component（接口） ：定义了一个对象接口，可以给这些对象动态地添加职责。这个接口是所有具体组件和装饰器的超类。
ConcreteComponent（具体组件） ：实现了Component接口，是被装饰的类。
Decorator（装饰器抽象类） ：装饰器抽象类，持有一个指向 Component 对象的引用，并实现了 Component 接口中定义的所有方法。装饰器可以在其方法中调用这些被装饰对象的方法，并可以在调用这些方法之前或之后添加额外的行为。
ConcreteDecorator（具体装饰器类） ：具体的装饰器类，继承自 Decorator 类，并向 Component 对象添加额外的职责。具体装饰器类可以添加多个职责，也可以链式地调用多个装饰器。
具体实现：
// Component 接口
interface Component {
void operation();
}
// ConcreteComponent 类，具体被装饰的对象
class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("ConcreteComponent operation");
}
}
// Decorator 类，装饰器抽象类
abstract class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
component.operation();
}
}
// ConcreteDecorator 类，具体的装饰器类
class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
@Override
public void operation() {
super.operation();
addedBehavior();
}
private void addedBehavior() {
System.out.println("ConcreteDecoratorA added behavior");
}
}
class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
@Override
public void operation() {
addedState();
super.operation();
}
private void addedState() {
System.out.println("ConcreteDecoratorB added state");
}
}
// 使用示例
public class DecoratorPatternDemo {
public static void main(String[] args) {
Component component = new ConcreteComponent();
// 链式装饰
component = new ConcreteDecoratorA(component);
component = new ConcreteDecoratorB(component);
// 执行操作
component.operation();
}
}职责链模式
定义：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系，将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
结构：
它包括三部分
1、Handler 接口或抽象类：定义了一个处理请求的接口。这个接口声明了一个处理请求的方法，该方法通常接受一个参数（即请求），并返回一个结果（例如，表示请求是否被处理的布尔值，或者一个更复杂的响应对象）。此外，接口或抽象类还可以包含一个指向下一个处理者的引用（即链中的下一个节点）。
2、ConcreteHandler 类：实现了 Handler 接口或继承自抽象类的具体处理者。每个 ConcreteHandler 对象都可以处理某些特定类型的请求，或者根据某些条件将请求传递给链中的下一个处理者。
3、Client 类：创建处理者链，并向链的头部发送请求。Client 类不知道哪个处理者最终会处理请求，它只是简单地将请求发送给链的起始点
具体实现：
// Handler 接口
interface Handler {
void handleRequest(String request);
Handler getNextHandler();
void setNextHandler(Handler nextHandler);
}
// ConcreteHandler 类，具体处理者
class ConcreteHandler1 implements Handler {
private Handler nextHandler;
@Override
public void handleRequest(String request) {
if (canHandle(request)) {
// 处理请求
System.out.println("ConcreteHandler1 handled: " + request);
} else {
// 如果不能处理，传递给下一个处理者
if (nextHandler != null) {
nextHandler.handleRequest(request);
}
}
}
private boolean canHandle(String request) {
// 判断是否能处理该请求的逻辑
return request.startsWith("A");
}
@Override
public Handler getNextHandler() {
return nextHandler;
}
@Override
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
}
// 另一个具体处理者，类似地实现 Handler 接口
class ConcreteHandler2 implements Handler {
// ...（与 ConcreteHandler1 类似的实现）
}
// Client 类
public class ChainOfResponsibilityDemo {
public static void main(String[] args) {
Handler handler1 = new ConcreteHandler1();
Handler handler2 = new ConcreteHandler2();
// 设置处理者链
handler1.setNextHandler(handler2);
// 发送请求
handler1.handleRequest("A-type request"); // ConcreteHandler1 会处理
handler1.handleRequest("B-type request"); // ConcreteHandler2 会处理（如果它的 canHandle 方法匹配）
}
}链式形成区别：
在装饰模式中，链式的形成主要是通过子类调用父类的接口或方法来实现的，但这并不是严格意义上的“链式”连接，因为装饰类并没有将请求传递给另一个装饰类，而是直接在被装饰对象上执行操作，但是装饰类可以嵌套使用，即一个装饰类可以装饰另一个装饰类，从而形成一个装饰链，这种嵌套使用的方式在某种程度上也体现了链式的思想。
在职责链模式中，链式的形成则是通过每个处理者（Handler）维护一个对下一个处理者的引用来实现的。具体来说： 每个处理者都实现了相同的接口或继承了相同的抽象类，定义了处理请求的方法。 处理者内部会维护一个对下一个处理者的引用（通常称为successor），以便在无法处理请求时将其传递给下一个处理者。这种机制实现了请求的发送者和接收者之间的解耦，增加了系统的灵活性和可扩展性。