1.解析
定义 ：
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
UML ：
2.实例
背景描述 ：
在前面的场景中 ，我们使用的是餐厅的例子 ，在这里可以继续延用 ： 薪资问题
人员结构 ：
* 基层 ： 服务员 ，洗碗工
* 中层 ：大厅经理，后厨主任
* 上层 ：总经理
* 高层 ：老板
* 强级 ：老板娘
场景 ：
* 基层 ： 想要申请 加薪；
* 中层： 最高给 其 加薪 1000元
* 高层 ：最高给其加薪 2000元
* 老板 ：最高给其加薪 3000元
* 老板娘 ： 最高给其加薪 4000元 或者 “ 不干滚蛋 ”
实现步骤 ：
层级结构构建 ： 管理层实现
（1）实现 SalaryHandler : 抽象类 ，抽象方法 ：addSalary(int salary);
public abstract class SalaryHandler {
//用于构建 责任链 的 链 ，是 所有层级（除了基层）的父类
private SalaryHandler salaryHandler;
public SalaryHandler getSalaryHandler() {
return salaryHandler;
}
public void setSalaryHandler(SalaryHandler salaryHandler) {
this.salaryHandler = salaryHandler;
}
public abstract void addSalary(int salary);
}（2）中层人员实现 : 大厅经理 ，后厨主任 ，控制加薪 1000元以内
public class ZhongCengHandler extends SalaryHandler {
/**
* 中层实现
*/
@Override
public void addSalary(int salary) {
if(salary<=1000){
System.out.println(this.getClass().getName()+" ：给 您加薪 "+salary+" 元");
}else{
getSalaryHandler().addSalary(salary);
}
}
}(3)高层人员 ： 总经理 ，控制加薪 2000元
public class GaoCengHandler extends SalaryHandler{
/**
* 高层实现
*/
@Override
public void addSalary(int salary) {
if(salary<=2000){
System.out.println(this.getClass().getName()+" ：给 您加薪 "+salary+" 元");
}else{
getSalaryHandler().addSalary(salary);
}
}
}(4) Boss 老板 ：控制加薪 3000元
public class BossHandler extends SalaryHandler {
/**
* 老板 最多加薪 3000元
*
*/
@Override
public void addSalary(int salary) {
if(salary<3000){
System.out.println(this.getClass().getName()+" ：给 您加薪 "+salary+" 元");
}else{
getSalaryHandler().addSalary(salary);
}
}
}(5) BossWife ： 老板娘 ，控制加薪4000元 和 辞员
public class BossWifeHandler extends SalaryHandler{
/**
* 老板娘 4000元
* 或 滚蛋
*/
@Override
public void addSalary(int salary) {
if(salary<4000){
System.out.println(this.getClass().getName()+" ：给您加薪 "+salary+" 元");
}else{
System.out.println(this.getClass().getName()+" : 不干滚蛋 ！");
}
}
}层级结构实现 ： 关联各个层之间的衔接
（6） SalaryFactory : 使用简单工厂模式 实现 各层之间的关联
public class SalaryFactory {
/**
* 关联起来 所有的 层
*/
public static SalaryHandler getSalaryHandlerInstance(){
ZhongCengHandler zhongCengHandler=new ZhongCengHandler();
GaoCengHandler gaoCengHandler=new GaoCengHandler();
BossHandler bossHandler=new BossHandler();
BossWifeHandler bossWifeHandler=new BossWifeHandler();
//关联
zhongCengHandler.setSalaryHandler(gaoCengHandler);
gaoCengHandler.setSalaryHandler(bossHandler);
bossHandler.setSalaryHandler(bossWifeHandler);
return zhongCengHandler;
}
}层级结构实现 ： 基层实现
（7） JiCengPerson ： 基层人员 实现 申请加薪
public class JiCengPerson {
private String name;
public JiCengPerson(String name) {
this.name = name;
}
/**
* 给上级说
*/
public void sayAddSalary(int salary) {
System.out.println(name + " : 我要加薪 " + salary + "元 ！！！懂？");
SalaryHandler handler = SalaryFactory.getSalaryHandlerInstance();
handler.addSalary(salary);
}
}测试实现
（8）测试
public static void main(String[] args) {
//基层提出 加薪
JiCengPerson xw=new JiCengPerson("小王");
xw.sayAddSalary(1100);
JiCengPerson xy=new JiCengPerson("小原");
xy.sayAddSalary(5100);
}结果 ：
3.优缺点
优点：
1. 将请求的发送者和接收者解耦 ；
2. 可以简化你的对象，因为它不需要知道链的结构 ；
3. 通过改变链内的成员或调动他们的次序，允许你动态地新增或删除责任；
缺点：
1. 并不保证请求一定会被执行，如果没有任何对象处理它的话，它可能会落到链尾端 之外 ；
2. 可能不容观察运行时的特征，有碍于除错。
3. 开始就会加载很多实例，消耗内存
4.使用场景
（1）有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
（2）你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
（3）可处理一个请求的对象集合应被动态指定。
