责任链模式：将请求的处理对象用一条长链组合起来，形成对象链。请求并不知道具体执行请求的对象是哪一个，这样就实现了请求与处理对象之间的解耦。
    在公司部门中，当你提交一份请求文件给你的直接上级，你的上级会将文件传递为他的直接上级，这样文件请求在这条链中传递，直到有人处理为止。
    责任链需要一个总接口，用来定义处理对象的公共部分（一般使用抽象类定义），公共部分包括：一个后继处理器，设置和获取后继处理器的方法，具体的请求处理方法（这个方法需要在每个具体处理对象中实现），这里定义为抽象方法。
    形成链：
    1. 需要在处理者对象中定义后继处理者对象，将这部分代码抽象到抽象类中实现，降低了代码重复性。
    2. 在处理者对象类中的处理方法中如果当前处理者对象无法处理，就将其传递到后继对象中。
    3. 在测试类中将这些处理者类的实例串联成串。
    特点：
    虽然实现请求额度传递，但是如果一旦不存在请求处理的类，那么这个请求一直存在链条中。
    如果设计成环形，这个请求将永远在环链中传递。
    由于请求的传递，处理效率会降低。

    1. /**
    2.  * 领导抽象类
    3.  */
    4. public abstract class LingDao {
    6.     private LingDao nextLingDao;
    8.     public LingDao getNextLingDao() {
    9.         return nextLingDao;
    10.     }
    12.     public void setNextLingDao(LingDao nextLingDao) {
    13.         this.nextLingDao = nextLingDao;
    14.     }
    16.     abstract void chuLi(Files files);
    17. }
    1. /**
    2.  * 文件
    3.  */
    4. public class Files {
    6.     private String fileName;
    7.     private int level;
    8.     public String getFileName() {
    9.         return fileName;
    10.     }
    11.     public void setFileName(String fileName) {
    12.         this.fileName = fileName;
    13.     }
    14.     public int getLevel() {
    15.         return level;
    16.     }
    17.     public void setLevel(int level) {
    18.         this.level = level;
    19.     }
    20. }
    1. /**
    2.  * 总经理
    3.  */
    4. public class Zongjingli extends LingDao {
    6.     private final String name = "总经理";
    8.     private final int level = 0;
    10.     @Override
    11.     void chuLi(Files files) {
    12.         if (this.level > files.getLevel()) {
    13.             System.out.println(name + "未处理文件");
    14.             getNextLingDao().chuLi(files);
    15.         } else {
    16.             System.out.println(name + "处理了文件");
    17.         }
    18.     }
    19. }
    1. /**
    2.  * 副总
    3.  */
    4. public class Fujingli extends LingDao {
    6.     private final String name = "副总";
    8.     private final int level = 0;
    10.     @Override
    11.     void chuLi(Files files) {
    12.         if (level == files.getLevel()) {
    13.             System.out.println(name + "未处理文件");
    14.             getNextLingDao().chuLi(files);
    15.         } else {
    16.             System.out.println(name + "处理了文件");
    17.         }
    18.     }
    19. }
    1. /**
    2.  * 主管
    3.  */
    4. public class ZhuGuan extends LingDao {
    6.     private final String name = "主管";
    8.     private final int level = 0;
    10.     @Override
    11.     void chuLi(Files files) {
    12.         if (level == files.getLevel()) {
    13.             System.out.println(name + "未处理文件");
    14.             getNextLingDao().chuLi(files);
    15.         } else {
    16.             System.out.println(name + "处理了文件");
    17.         }
    18.     }
    19. }
    1. public class Clienter {
    3.     public static void main(String[] args) {
    4.         LingDao zongJingLi = new Zongjingli();
    5.         LingDao fuJingLi = new Fujingli();
    6.         LingDao zhuGuan = new ZhuGuan();
    8.         zhuGuan.setNextLingDao(fuJingLi);
    9.         fuJingLi.setNextLingDao(zongJingLi);
    11.         //定义两份文件
    12.         Files f1 = new Files();
    13.         f1.setFileName("正确对待旱鸭子");
    14.         f1.setLevel(1);
    16.         Files f2 = new Files();
    17.         f2.setFileName("年会举办");
    18.         f2.setLevel(0);
    20.         //提交文件
    21.         zhuGuan.chuLi(f1);
    22.         zhuGuan.chuLi(f2);
    24.         //主管处理了文件
    25.         //主管未处理文件
    26.         //副总未处理文件
    27.         //总经理处理了文件
    28.     }
    29. }