新增Python基础知识

设计模式/04. 行为模式/12. 责任链模式/责任链模式.md

+## 责任链模式的定义
+
+责任链模式也叫职责链模式，为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
+
+在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，所以责任链将请求的发送者和请求的处理者解耦了。
+
+## 责任链模式优缺点
+
+优点：
+
+- 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
+- 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
+- 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
+- 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
+- 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。
+
+缺点：
+
+- 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
+- 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
+- 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。
+
+## 责任链模式的实现
+
+通常情况下，可以通过数据链表来实现职责链模式的数据结构。
+
+职责链模式主要包含以下角色。
+
+- 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
+- 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
+- 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。
+
+![](img/01.png)
+
+客户端可按如图所示设置责任链：
+
+![](img/02.png)
+
+## 责任链模式的应用实例
+
+**用责任链模式设计一个请假条审批模块**
+
+> 分析：假如规定学生请假小于或等于 2 天，班主任可以批准；小于或等于 7 天，系主任可以批准；小于或等于 10 天，院长可以批准；其他情况不予批准；这个实例适合使用职责链模式实现。
+
+首先，定义一个领导类（`Leader`），它是抽象处理者，包含了一个指向下一位领导的指针 `next` 和一个处理假条的抽象处理方法 `handleRequest(int LeaveDays)`；然后，定义班主任类（`ClassAdviser`）、系主任类（`DepartmentHead`）和院长类（`Dean`），它们是抽象处理者的子类，是具体处理者，必须根据自己的权力去实现父类的 `handleRequest(int LeaveDays)` 方法，如果无权处理就将假条交给下一位具体处理者，直到最后；客户类负责创建处理链，并将假条交给链头的具体处理者（班主任），下图所示是其结构图。
+
+![](img/03.gif)
+
+【抽象处理者】
+
+```java
+public abstract class Leader {
+    private Leader next;
+
+    public void setNext(Leader next) {
+        this.next = next;
+    }
+
+    public Leader getNext() {
+        return next;
+    }
+
+    //处理请求的方法
+    public abstract void handleRequest(int LeaveDays);
+}
+```
+
+【班主任】
+
+```java
+public class ClassAdviser extends Leader{
+    @Override
+    public void handleRequest(int LeaveDays) {
+        if (LeaveDays <= 2) {
+            System.out.println("班主任批准您请假" + LeaveDays + "天。");
+        } else {
+            if (getNext() != null) {
+                getNext().handleRequest(LeaveDays);
+            } else {
+                System.out.println("请假天数太多，没有人批准该假条！");
+            }
+        }
+    }
+}
+```
+
+【系主任】
+
+```java
+public class DepartmentHead extends Leader{
+    @Override
+    public void handleRequest(int LeaveDays) {
+        if (LeaveDays <= 7) {
+            System.out.println("系主任批准您请假" + LeaveDays + "天。");
+        } else {
+            if (getNext() != null) {
+                getNext().handleRequest(LeaveDays);
+            } else {
+                System.out.println("请假天数太多，没有人批准该假条！");
+            }
+        }
+    }
+}
+```
+
+【院长】
+
+```java
+public class Dean extends Leader{
+    @Override
+    public void handleRequest(int LeaveDays) {
+        if (LeaveDays <= 10) {
+            System.out.println("院长批准您请假" + LeaveDays + "天。");
+        } else {
+            if (getNext() != null) {
+                getNext().handleRequest(LeaveDays);
+            } else {
+                System.out.println("请假天数太多，没有人批准该假条！");
+            }
+        }
+    }
+}
+```
+
+【测试类】
+
+```java
+public class Test {
+    public static void main(String[] args) {
+        //组装责任链
+        Leader teacher1 = new ClassAdviser();
+        Leader teacher2 = new DepartmentHead();
+        Leader teacher3 = new Dean();
+        teacher1.setNext(teacher2);
+        teacher2.setNext(teacher3);
+        //提交请求
+        teacher1.handleRequest(12);
+    }
+}
+```
+
+输出：
+
+```
+请假天数太多，没有人批准该假条！
+```
+
+假如增加一个教务处长类，可以批准学生请假 20 天，也非常简单，代码如下：
+
+【教务处长】
+
+```java
+public class DeanOfStudies extends Leader{
+    @Override
+    public void handleRequest(int LeaveDays) {
+        if (LeaveDays <= 20) {
+            System.out.println("教务处长批准您请假" + LeaveDays + "天。");
+        } else {
+            if (getNext() != null) {
+                getNext().handleRequest(LeaveDays);
+            } else {
+                System.out.println("请假天数太多，没有人批准该假条！");
+            }
+        }
+    }
+}
+```
+
+【测试类】
+
+```java
+public class Test {
+    public static void main(String[] args) {
+        //组装责任链
+        Leader teacher1 = new ClassAdviser();
+        Leader teacher2 = new DepartmentHead();
+        Leader teacher3 = new Dean();
+        Leader teacher4=new DeanOfStudies();
+        teacher1.setNext(teacher2);
+        teacher2.setNext(teacher3);
+        teacher3.setNext(teacher4);
+        //提交请求
+        teacher1.handleRequest(12);
+    }
+}
+```
+
+输出：
+
+```
+教务处长批准您请假12天。
+```
+
+## 模式的应用场景
+
+前边已经讲述了关于责任链模式的结构与特点，下面介绍其应用场景，责任链模式通常在以下几种情况使用。
+
+1. 多个对象可以处理一个请求，但具体由哪个对象处理该请求在运行时自动确定。
+2. 可动态指定一组对象处理请求，或添加新的处理者。
+3. 需要在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求。
+
+## 模式的扩展
+
+职责链模式存在以下两种情况。
+
+1. 纯的职责链模式：一个请求必须被某一个处理者对象所接收，且一个具体处理者对某个请求的处理只能采用以下两种行为之一：自己处理（承担责任）；把责任推给下家处理。
+2. 不纯的职责链模式：允许出现某一个具体处理者对象在承担了请求的一部分责任后又将剩余的责任传给下家的情况，且一个请求可以最终不被任何接收端对象所接收。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

设计模式/04. 行为模式/13. 命令模式/命令模式.md

+## 命令模式定义
+
+**命令（Command）模式**的定义如下：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。
+
+
+
+命令模式的主要优点如下。
+
+1. 通过引入中间件（抽象接口）降低系统的耦合度。
+2. 扩展性良好，增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，且满足“开闭原则”。
+3. 可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
+4. 方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。
+5. 可以在现有命令的基础上，增加额外功能。比如日志记录，结合装饰器模式会更加灵活。
+
+其缺点是：
+
+1. 可能产生大量具体的命令类。因为每一个具体操作都需要设计一个具体命令类，这会增加系统的复杂性。
+2. 命令模式的结果其实就是接收方的执行结果，但是为了以命令的形式进行架构、解耦请求与实现，引入了额外类型结构（引入了请求方与抽象命令接口），增加了理解上的困难。不过这也是设计模式的通病，抽象必然会额外增加类的数量，代码抽离肯定比代码聚合更加难理解。
+
+## 命令模式结构
+
+![](img/01.gif)
+
+命令模式包含以下主要角色。
+
+1. 抽象命令类（Command）角色：声明执行命令的接口，拥有执行命令的抽象方法 execute()。
+2. 具体命令类（Concrete Command）角色：是抽象命令类的具体实现类，它拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。
+3. 实现者/接收者（Receiver）角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者。
+4. 调用者/请求者（Invoker）角色：是请求的发送者，它通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，它不直接访问接收者。
+
+## 应用示例
+
+【抽象命令】
+
+```java
+public interface Command {
+    void execute();
+}
+```
+
+【调用者】
+
+```java
+public class Invoker {
+    private Command command;
+
+    public Invoker(Command command) {
+        this.command = command;
+    }
+
+    public void setCommand(Command command) {
+        this.command = command;
+    }
+
+    public void call(){
+        System.out.println("调用者执行命令command...");
+        command.execute();
+    }
+}
+```
+
+【接受者】
+
+```java
+public class Receiver {
+    public void action(){
+        System.out.println("接受者的action()方法被调用...");
+    }
+}
+```
+
+【具体命令】
+
+```java
+public class ConcreteCommand implements Command{
+
+    private Receiver receiver;
+
+    public ConcreteCommand(Receiver receiver) {
+        this.receiver = receiver;
+    }
+
+    @Override
+    public void execute() {
+        receiver.action();
+    }
+}
+```
+
+【测试类】
+
+```java
+public class Test {
+    public static void main(String[] args) {
+        Receiver receiver = new Receiver();
+        ConcreteCommand cmd = new ConcreteCommand(receiver);
+        Invoker invoker = new Invoker(cmd);
+        System.out.println("客户访问调用者的call()方法...");
+        invoker.call();
+    }
+}
+```
+
+输出结果：
+
+```
+客户访问调用者的call()方法...
+调用者执行命令command...
+接受者的action()方法被调用...
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

设计模式/04. 行为模式/14. 迭代器模式/迭代器模式.md

+在现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如“数据结构”中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”。
+
+既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点：
+
+1. 暴露了聚合类的内部表示，使其数据不安全；
+2. 增加了客户的负担。
+
+“迭代器模式”能较好地克服以上缺点，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足“单一职责原则”和“开闭原则”，如 Java 中的 Collection、List、Set、Map 等都包含了迭代器。
+
+迭代器模式在生活中应用的比较广泛，比如：物流系统中的传送带，不管传送的是什么物品，都会被打包成一个个箱子，并且有一个统一的二维码。这样我们不需要关心箱子里是什么，在分发时只需要一个个检查发送的目的地即可。再比如，我们平时乘坐交通工具，都是统一刷卡或者刷脸进站，而不需要关心是男性还是女性、是残疾人还是正常人等信息。
+
+## 模式的定义与特点
+
+迭代器（Iterator）模式的定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。迭代器模式是一种对象行为型模式，其主要优点如下。
+
+1. 访问一个聚合对象的内容而无须暴露它的内部表示。
+2. 遍历任务交由迭代器完成，这简化了聚合类。
+3. 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
+4. 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
+5. 封装性良好，为遍历不同的聚合结构提供一个统一的接口。
+
+其主要缺点是：增加了类的个数，这在一定程度上增加了系统的复杂性。
+
+在日常开发中，我们几乎不会自己写迭代器。除非需要定制一个自己实现的数据结构对应的迭代器，否则，开源框架提供的 API 完全够用。
+
+## 模式的结构与实现
+
+迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。现在我们来分析其基本结构与实现方法。
+
+![](img/01.gif)
+
+迭代器模式主要包含以下角色。
+
+1. 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
+2. 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
+3. 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
+4. 具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。
+
+【抽象迭代器】
+
+```java
+public interface Iterator {
+    Object first();
+    Object next();
+    boolean hasNext();
+}
+```
+
+【具体迭代器】
+
+```java
+public class ConcreteIterator implements Iterator {
+    private List<Object> list = null;
+    private int index = -1;
+
+    public ConcreteIterator(List<Object> list) {
+        this.list = list;
+    }
+
+    @Override
+    public Object first() {
+        index = 0;
+        Object obj = list.get(index);
+        ;
+        return obj;
+    }
+
+    @Override
+    public Object next() {
+        Object obj = null;
+        if (this.hasNext()) {
+            obj = list.get(++index);
+        }
+        return obj;
+    }
+
+    @Override
+    public boolean hasNext() {
+        if (index < list.size() - 1) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+```
+
+【抽象聚合】
+
+```java
+public interface Aggregate {
+    void add(Object obj);
+    void remove(Object obj);
+    Iterator iterator();
+}
+```
+
+【具体聚合】
+
+```java
+public class ConcreteAggregate implements Aggregate{
+    private List<Object> list = new ArrayList<>();
+
+    @Override
+    public void add(Object obj) {
+        list.add(obj);
+    }
+
+    @Override
+    public void remove(Object obj) {
+        list.remove(obj);
+    }
+
+    @Override
+    public Iterator iterator() {
+        return new ConcreteIterator(list);
+    }
+}
+```
+
+【测试类】
+
+```java
+public class Test {
+    public static void main(String[] args) {
+        Aggregate ag = new ConcreteAggregate();
+        ag.add("中山大学");
+        ag.add("华南理工");
+        ag.add("韶关学院");
+        System.out.print("聚合的内容有：");
+        Iterator it = ag.iterator();
+        while (it.hasNext()) {
+            Object ob = it.next();
+            System.out.print(ob.toString() + "\t");
+        }
+        Object ob = it.first();
+        System.out.println("\nFirst：" + ob.toString());
+    }
+}
+```
+
+输出结果：
+
+```
+聚合的内容有：中山大学	华南理工	韶关学院	
+First：中山大学
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

设计模式/design pattern/src/main/java/com/ice/behavior/Command/Command.java

+package com.ice.behavior.Command;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-11-01 09:20:15
+ */
+public interface Command {
+    void execute();
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Command/ConcreteCommand.java

+package com.ice.behavior.Command;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-11-01 09:27:56
+ */
+public class ConcreteCommand implements Command{
+
+    private Receiver receiver;
+
+    public ConcreteCommand(Receiver receiver) {
+        this.receiver = receiver;
+    }
+
+    public ConcreteCommand() {
+
+    }
+
+    @Override
+    public void execute() {
+        receiver.action();
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Command/Invoker.java

+package com.ice.behavior.Command;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-11-01 09:20:01
+ */
+public class Invoker {
+    private Command command;
+
+    public Invoker(Command command) {
+        this.command = command;
+    }
+
+    public void setCommand(Command command) {
+        this.command = command;
+    }
+
+    public void call(){
+        System.out.println("调用者执行命令command...");
+        command.execute();
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Command/Receiver.java

+package com.ice.behavior.Command;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-11-01 09:28:21
+ */
+public class Receiver {
+    public void action(){
+        System.out.println("接受者的action()方法被调用...");
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Command/Test.java

+package com.ice.behavior.Command;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-11-01 09:32:19
+ */
+public class Test {
+    public static void main(String[] args) {
+        Receiver receiver = new Receiver();
+        ConcreteCommand cmd = new ConcreteCommand(receiver);
+        Invoker invoker = new Invoker(cmd);
+        System.out.println("客户访问调用者的call()方法...");
+        invoker.call();
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Iterator/Aggregate.java

+package com.ice.behavior.Iterator;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-11-01 10:32:27
+ */
+public interface Aggregate {
+    void add(Object obj);
+
+    void remove(Object obj);
+
+    Iterator iterator();
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Iterator/ConcreteAggregate.java

+package com.ice.behavior.Iterator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-11-01 10:57:13
+ */
+public class ConcreteAggregate implements Aggregate{
+    private List<Object> list = new ArrayList<>();
+
+    @Override
+    public void add(Object obj) {
+        list.add(obj);
+    }
+
+    @Override
+    public void remove(Object obj) {
+        list.remove(obj);
+    }
+
+    @Override
+    public Iterator iterator() {
+        return new ConcreteIterator(list);
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Iterator/ConcreteIterator.java

+package com.ice.behavior.Iterator;
+
+import java.util.List;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-11-01 10:58:26
+ */
+public class ConcreteIterator implements Iterator {
+    private List<Object> list = null;
+    private int index = -1;
+
+    public ConcreteIterator(List<Object> list) {
+        this.list = list;
+    }
+
+    @Override
+    public Object first() {
+        index = 0;
+        Object obj = list.get(index);
+        ;
+        return obj;
+    }
+
+    @Override
+    public Object next() {
+        Object obj = null;
+        if (this.hasNext()) {
+            obj = list.get(++index);
+        }
+        return obj;
+    }
+
+    @Override
+    public boolean hasNext() {
+        if (index < list.size() - 1) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Iterator/Iterator.java

+package com.ice.behavior.Iterator;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-11-01 10:54:41
+ */
+public interface Iterator {
+    Object first();
+    Object next();
+    boolean hasNext();
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Iterator/Test.java

+package com.ice.behavior.Iterator;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-11-01 11:00:43
+ */
+public class Test {
+    public static void main(String[] args) {
+        Aggregate ag = new ConcreteAggregate();
+        ag.add("中山大学");
+        ag.add("华南理工");
+        ag.add("韶关学院");
+        System.out.print("聚合的内容有：");
+        Iterator it = ag.iterator();
+        while (it.hasNext()) {
+            Object ob = it.next();
+            System.out.print(ob.toString() + "\t");
+        }
+        Object ob = it.first();
+        System.out.println("\nFirst：" + ob.toString());
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Resposibility/ClassAdviser.java

+package com.ice.behavior.Resposibility;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-10-31 22:01:54
+ */
+public class ClassAdviser extends Leader{
+    @Override
+    public void handleRequest(int LeaveDays) {
+        if (LeaveDays <= 2) {
+            System.out.println("班主任批准您请假" + LeaveDays + "天。");
+        } else {
+            if (getNext() != null) {
+                getNext().handleRequest(LeaveDays);
+            } else {
+                System.out.println("请假天数太多，没有人批准该假条！");
+            }
+        }
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Resposibility/Dean.java

+package com.ice.behavior.Resposibility;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-10-31 22:03:01
+ */
+public class Dean extends Leader{
+    @Override
+    public void handleRequest(int LeaveDays) {
+        if (LeaveDays <= 10) {
+            System.out.println("院长批准您请假" + LeaveDays + "天。");
+        } else {
+            if (getNext() != null) {
+                getNext().handleRequest(LeaveDays);
+            } else {
+                System.out.println("请假天数太多，没有人批准该假条！");
+            }
+        }
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Resposibility/DeanOfStudies.java

+package com.ice.behavior.Resposibility;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-10-31 22:05:21
+ */
+public class DeanOfStudies extends Leader{
+    @Override
+    public void handleRequest(int LeaveDays) {
+        if (LeaveDays <= 20) {
+            System.out.println("教务处长批准您请假" + LeaveDays + "天。");
+        } else {
+            if (getNext() != null) {
+                getNext().handleRequest(LeaveDays);
+            } else {
+                System.out.println("请假天数太多，没有人批准该假条！");
+            }
+        }
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Resposibility/DepartmentHead.java

+package com.ice.behavior.Resposibility;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-10-31 22:02:30
+ */
+public class DepartmentHead extends Leader{
+    @Override
+    public void handleRequest(int LeaveDays) {
+        if (LeaveDays <= 7) {
+            System.out.println("系主任批准您请假" + LeaveDays + "天。");
+        } else {
+            if (getNext() != null) {
+                getNext().handleRequest(LeaveDays);
+            } else {
+                System.out.println("请假天数太多，没有人批准该假条！");
+            }
+        }
+    }
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Resposibility/Leader.java

+package com.ice.behavior.Resposibility;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-10-31 22:00:07
+ */
+public abstract class Leader {
+    private Leader next;
+
+    public void setNext(Leader next) {
+        this.next = next;
+    }
+
+    public Leader getNext() {
+        return next;
+    }
+
+    //处理请求的方法
+    public abstract void handleRequest(int LeaveDays);
+}

设计模式/design pattern/src/main/java/com/ice/behavior/Resposibility/Test.java

+package com.ice.behavior.Resposibility;
+
+/**
+ * @author ice
+ * @blog https://blog.csdn.net/dreaming_coder
+ * @description
+ * @create 2021-10-31 22:07:24
+ */
+public class Test {
+    public static void main(String[] args) {
+        //组装责任链
+        Leader teacher1 = new ClassAdviser();
+        Leader teacher2 = new DepartmentHead();
+        Leader teacher3 = new Dean();
+        Leader teacher4=new DeanOfStudies();
+        teacher1.setNext(teacher2);
+        teacher2.setNext(teacher3);
+        teacher3.setNext(teacher4);
+        //提交请求
+        teacher1.handleRequest(12);
+    }
+}