设计模式中使用链式设计的有两个，装饰模式和职责链模式
装饰模式
定义：
动态的给一个对象添加一些额外的职责
结构：
它包括四部分
Component（接口） ：定义了一个对象接口，可以给这些对象动态地添加职责。这个接口是所有具体组件和装饰器的超类。
ConcreteComponent（具体组件） ：实现了Component接口，是被装饰的类。
Decorator（装饰器抽象类） ：装饰器抽象类，持有一个指向 Component 对象的引用，并实现了 Component 接口中定义的所有方法。装饰器可以在其方法中调用这些被装饰对象的方法，并可以在调用这些方法之前或之后添加额外的行为。
ConcreteDecorator（具体装饰器类） ：具体的装饰器类，继承自 Decorator 类，并向 Component 对象添加额外的职责。具体装饰器类可以添加多个职责，也可以链式地调用多个装饰器。
具体实现：
// Component 接口
interface Component {void operation();
}// ConcreteComponent 类，具体被装饰的对象
class ConcreteComponent implements Component {@Overridepublic void operation() {System.out.println("ConcreteComponent operation");}
}// Decorator 类，装饰器抽象类
abstract class Decorator implements Component {protected Component component;public Decorator(Component component) {this.component = component;}@Overridepublic void operation() {component.operation();}
}// ConcreteDecorator 类，具体的装饰器类
class ConcreteDecoratorA extends Decorator {public ConcreteDecoratorA(Component component) {super(component);}@Overridepublic void operation() {super.operation();addedBehavior();}private void addedBehavior() {System.out.println("ConcreteDecoratorA added behavior");}
}class ConcreteDecoratorB extends Decorator {public ConcreteDecoratorB(Component component) {super(component);}@Overridepublic 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;@Overridepublic 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");}@Overridepublic Handler getNextHandler() {return nextHandler;}@Overridepublic 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），以便在无法处理请求时将其传递给下一个处理者。这种机制实现了请求的发送者和接收者之间的解耦，增加了系统的灵活性和可扩展性。
