责任链模式也是属于行为模式，行为型模式就是把不同行为抽离成一个模板和使用模板的主体产生聚合或者组合，责任链模式就是对消息的两端分离，对消息的发送者和接收消息的处理者进行解耦，将消息处理者对象组合成链状，消息再在链条中转递，交给相应的处理者对象

问题：假如WQL要租房子，现在有A，B，C三个房东，A房东出租价格小于1000，B房东出租价格在1000~2000之间，C房东出租价格在2000~3000之间，WQL要根据自己的需求选房子

传统方式解决：

传统方式就是定义WQL，A，B，C四个类，在WQL方法种if判断价格，依次判断条件是否符号，如果符号就调用房东里面的出租方法

public class 传统写法 {
    public static void main(String[] args) {
               Userwql WQL=new Userwql(500);
               WQL.V();
    }
}
class Userwql{
    int money;
    A1 A;
    B1 B;
    C1 C;
  public Userwql(int money){
      this.money=money;
  }
  //判断数据方法全都在用户方法里面，假如还有其他房东，代码还要挨个再写下去，代码冗余，而且用户与每个房东class都有耦合关系，
    //责任链模式不同，用户把数据发出去，房东方法自己形成链状，如果不符合条件往下再推送
public void V(){
      if(money<1000){
         A=new A1();
         A.succeed();
      }else if(money>1000 && money<2000){
          B=new B1();
          B.succeed();
      }else if(money>2000 && money<3000){
          C=new C1();
          C.succeed();
      } }}
class A1{
public void succeed(){
    System.out.print("房东A把房子租给了WQL");
}
}
class B1{
    public void succeed(){
        System.out.print("房东A把房子租给了WQL");
    }}
class C1{
    public void succeed(){
        System.out.print("房东A把房子租给了WQL");
    }

}

弊端:
1，数据的发送者(这里指WQL租房信息的发送给房东)和数据的接收者耦合度高
2，数据的判断逻辑处理在发送者，接收者越多，代码冗余也就越多

责任链模式解决：
在WQL和房东之间定义一个抽象类，充当中间解耦带，类似于中中介，它接收发送者的数据，交给每个数据的接收者，类似于租          房者在中介哪里说要租房子，中介把租房者的信息给了房东，房东判断自己的条件和租房者的条件是否一致，如果一致就联系中介可以出          租，如果不一致就给下一个房东，在接收者中间形成推送(本质是父类的递归)

public class user {
    public static void main(String[] args) {

        WQLuser WQL=new WQLuser();
        WQL.setMoney(1900);
        A  a=new A();
        B  b=new B();
        C  c=new C();
        a.condition(WQL,b);
        b.condition(WQL,c);
        c.condition(WQL,a);
    }
}

class WQLuser{
    private int money;
    public int getMoney(){
        return money;
    }
    public void setMoney(int a){
        this.money=a;
    }
}

abstract class Intermediary{
   private Intermediary intermediary;
    public void setIntermediary(Intermediary a){
        this.intermediary=a;
    }
   abstract public void condition(WQLuser WQL,Intermediary a);
}

class A extends Intermediary{
    @Override
    public void condition(WQLuser WQL,Intermediary B) {
        if(WQL.getMoney()<1000){
            System.out.print("A房东把房子租给了WQL");
        }else{
            setIntermediary(B);
        }
    }

}



class B extends Intermediary{
    @Override
    public void condition(WQLuser WQL,Intermediary C) {
        if(1000<WQL.getMoney() && WQL.getMoney()<2000){
            System.out.print("B房东把房子租给了WQL");
        }else{
            setIntermediary(C);
        }
    }

}

class C extends Intermediary{
    @Override
    public void condition(WQLuser WQL,Intermediary A) {
        if(WQL.getMoney()>2000 && WQL.getMoney()<3000){
            System.out.print("C房东把房子租给了WQL");
        }else{
            setIntermediary(A);
        }
    }

}

优点：

1，发送者与接收者解耦

2，数据的处理在接收者一方，如果添加接收者，发送者没有影响，代码冗余少