链式设计模式

链式设计模式——装饰器模式和职责链模式

装饰模式

定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。

结构

装饰（Decorator）模式中的角色：

抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。
具体构件（Concrete Component）角色：实现抽象构件，通过装饰角色为其添加一些职责。
抽象装饰（Decorator）角色：继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
具体装饰（ConcreteDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任

结构图

例子

以快餐店买饭有不同配菜为例

//快餐接口
public abstract class FastFood {
 private float price;
 private String desc;
 public FastFood() {
 }
 public FastFood(float price, String desc) {
 this.price = price;
 this.desc = desc;
 }
 public void setPrice(float price) {
 this.price = price;
 }
 public float getPrice() {
 return price;
 }
 public String getDesc() {
 return desc;
 }
 public void setDesc(String desc) {
 this.desc = desc;
 }
 public abstract float cost();  //获取价格
}




 //炒饭
public class FriedRice extends FastFood {
 public FriedRice() {
 super(10, "炒饭");
 }
 public float cost() {
 return getPrice();
 }
 }



 //炒面
public class FriedNoodles extends FastFood {
 public FriedNoodles() {
 super(12, "炒面");
 }
 public float cost() {
 return getPrice();
 }
 }



 //配料类
public abstract class Garnish extends FastFood {
 private FastFood fastFood;
 public FastFood getFastFood() {
 return fastFood;
 }
 public void setFastFood(FastFood fastFood) {
 this.fastFood = fastFood;
 }
 public Garnish(FastFood fastFood, float price, String desc) {
 super(price,desc);
 this.fastFood = fastFood;
 }
 }



 //鸡蛋配料
public class Egg extends Garnish {
 public Egg(FastFood fastFood) {
 super(fastFood,1,"鸡蛋");
 }
 public float cost() {
 return getPrice() + getFastFood().getPrice();
 }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
 }



 //培根配料
public class Bacon extends Garnish {
    public Bacon(FastFood fastFood) {
        super(fastFood,2,"培根");
    }
    @Override
    public float cost() {
        return getPrice() + getFastFood().getPrice();
    }
    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
 }



 //测试类
public class Client {
    public static void main(String[] args) {
        //点一份炒饭
        FastFood food = new FriedRice();
        //花费的价格
        System.out.println(food.getDesc() + " " + food.cost() + "元");
        System.out.println("========");
        //点一份加鸡蛋的炒饭
        FastFood food1 = new FriedRice();
        food1 = new Egg(food1);
        //花费的价格
        System.out.println(food1.getDesc() + " " + food1.cost() + "元");
        System.out.println("========");
        //点一份加培根的炒面
        FastFood food2 = new FriedNoodles();
        food2 = new Bacon(food2);
        //花费的价格
        System.out.println(food2.getDesc() + " " + food2.cost() + "元");
    }
 }

好处

装饰模式可以带来比继承更加灵活性的扩展功能，使用更加方便，可以通过组合不同的装饰对象来获取具有不同行为状态的多样化的结果。
装饰模式比继承更具良好的扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任。
装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能

职责链模式

定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

结构

职责链模式主要包含以下角色:

抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

结构图

例子

以请假流程为例

 //请假条
public class LeaveRequest {
 private String name;//姓名
private int num;//请假天数
    private String content;//请假内容
    public LeaveRequest(String name, int num, String content) {
        this.name = name;
        this.num = num;
        this.content = content;
    }
    public String getName() {
        return name;
    }
    public int getNum() {
        return num;
    }
    public String getContent() {
        return content;
    }
 }




 //处理者抽象类
public abstract class Handler {
    protected final static int NUM_ONE = 1;
    protected final static int NUM_THREE = 3;
    protected final static int NUM_SEVEN = 7;
    //该领导处理的请假天数区间
    private int numStart;
    private int numEnd;
    //领导上面还有领导
    private Handler nextHandler;
    //设置请假天数范围 上不封顶
    public Handler(int numStart) {
        this.numStart = numStart;
    }
    //设置请假天数范围
    public Handler(int numStart, int numEnd) {
        this.numStart = numStart;
        this.numEnd = numEnd;
    }
    //设置上级领导
    public void setNextHandler(Handler nextHandler){
        this.nextHandler = nextHandler;
    }
    //提交请假条
    public final void submit(LeaveRequest leave){
        if(0 == this.numStart){
            return;
        }
        //如果请假天数达到该领导者的处理要求
        if(leave.getNum() >= this.numStart){
            this.handleLeave(leave);
            //如果还有上级 并且请假天数超过了当前领导的处理范围
            if(null != this.nextHandler && leave.getNum() > numEnd){
                this.nextHandler.submit(leave);//继续提交
            } else {
                System.out.println("流程结束");
            }
        }
    }
    //各级领导处理请假条方法
    protected abstract void handleLeave(LeaveRequest leave);
 }




 //小组长
public class GroupLeader extends Handler {
    public GroupLeader() {
        //小组长处理1-3天的请假
        super(Handler.NUM_ONE, Handler.NUM_THREE);
    }
    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + 
"天," + leave.getContent() + "。");
        System.out.println("小组长审批：同意。");
    }
 }




 //部门经理
public class Manager extends Handler {
    public Manager() {
        //部门经理处理3-7天的请假
        super(Handler.NUM_THREE, Handler.NUM_SEVEN);
    }
    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + 
"天," + leave.getContent() + "。");
        System.out.println("部门经理审批：同意。");
    }
 }




 //总经理
public class GeneralManager extends Handler {
    public GeneralManager() {
        //部门经理处理7天以上的请假
        super(Handler.NUM_SEVEN);
    }
    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + 
"天," + leave.getContent() + "。");
        System.out.println("总经理审批：同意。");
    }

 }



 //测试类
public class Client {
 public static void main(String[] args) {
 //请假条来一张
LeaveRequest leave = new LeaveRequest("小花",5,"身体不适");
 //各位领导
GroupLeader groupLeader = new GroupLeader();
 Manager manager = new Manager();
 GeneralManager generalManager = new GeneralManager();
 groupLeader.setNextHandler(manager);//小组长的领导是部门经理
manager.setNextHandler(generalManager);//部门经理的领导是总经理
//之所以在这里设置上级领导，是因为可以根据实际需求来更改设置，如果实战中上级领
导人都是固定的，则可以移到领导实现类中。
//提交申请
groupLeader.submit(leave);
 }
 }

优点