深入理解软件设计模式

1.3 什么是多态特性

    /**     * 和尚取水:实现一个和尚挑水喝，两个和尚抬水喝，三个和尚等水喝     */    public void fetchWater(){        //         for (int heShangNum = 1; heShangNum < 4; heShangNum++) {            Waterable waterable = Factory.getWaterable(heShangNum);            Water water = waterable.getWater();        }    }

public class ToolBox {    private final String bianDan;    private final String muTong;    private final String muGun;
    private ToolBox(TiaoBuilder builder){        this.bianDan=builder.bianDan;        this.muTong=builder.muTong;        this.muGun = null;    }    private ToolBox(TaiBuilder builder){        this.bianDan = null;        this.muTong = null;        this.muGun=builder.muGun;    }    private ToolBox(DengBuilder builder){        this.bianDan = null;        this.muTong = null;        this.muGun=null;    }    public static class TiaoBuilder{        private String bianDan;        private String muTong;
        public TiaoBuilder setBianDan(String bianDan) {            this.bianDan = bianDan;            return this;        }        public TiaoBuilder setMuTong(String muTong) {            this.muTong = muTong;            return this;        }        public ToolBox build(){            return new ToolBox(this);        }    }
    public static class TaiBuilder{        private String muGun;        private String muTong;
        public TaiBuilder setMuGun(String muGun) {            this.muGun = muGun;            return this;        }        public TaiBuilder setMuTong(String muTong) {            this.muTong = muTong;            return this;        }        public ToolBox build(){            return new ToolBox(this);        }    }
    public static class DengBuilder{        public ToolBox build(){            return new ToolBox(this);        }    }
    //省略getter方法}

ToolBox oneHeShangToolBox = new ToolBox.TiaoBuilder().setMuTong("小号木桶").setBianDan("小号扁担").build();ToolBox twoHeShangToolBox = new ToolBox.TaiBuilder().setMuTong("大号木桶").setMuGun("长号木棍").build();ToolBox threeHeShangToolBox = new ToolBox.DengBuilder().build();

    public class WaterableProxy implements Waterable{    /**     * 被代理的原始对象     */    private Waterable waterable;
    public WaterableProxy(Waterable waterable) {        this.waterable = waterable;    }
    @Override    public Water getWater() {        Water water = waterable.getWater();        // 增强的新功能，不管是挑水，抬水，等水，只有带回来水，就可以        if(water != "无水"){            System.out.println("我敲一下木鱼，打一次卡！");        }        return water;    }}

    public void doProxy(){        Waterable waterable = new Taishui();        WaterableProxy proxyWaterable = new WaterableProxy(waterable);        proxyWaterable.getWater();    }

public class ZhuChiCmd implements PipelineCmd {    private Command command;    private transient OrderHandler orderHandler;
    public StepCmd(Command command, OrderHandler orderHandler) {        this.command = command;        this.orderHandler= orderHandler;    }
    @Override    public PipeResult execute(PipeContext pipeContext) {        return orderHandler.execute(new CallContext(command, pipeContext));    }    // 省略get和set方法}

public class Breakfast implements OrderHandler { /**     * 执行逻辑     *     * @param callContext     * @return     */    PipeResult execute(CallContext callContext){        System.out.println("做早餐啦！");    }    /**     * 支持的指令类型：做早餐，打扫，敲钟等指令标识     *     * @return     */    OrderTypeEnum getOrderType(){        return OrderTypeEnum.BREAKFAST;    }
}
public class Clean implements OrderHandler { /**     * 执行逻辑     *     * @param callContext     * @return     */    PipeResult execute(CallContext callContext){        System.out.println("打扫庭院啦！");    }    /**     * 支持的指令类型：做早餐，打扫，敲钟等命令标识     *     * @return     */    OrderTypeEnum getOrderType(){        return OrderTypeEnum.CLEAN;    }
}
public class Ring implements OrderHandler { /**     * 执行逻辑     *     * @param callContext     * @return     */    PipeResult execute(CallContext callContext){        System.out.println("敲钟啦！");    }    /**     * 支持的命令类型：做早餐，打扫，敲钟等指令标识     *     * @return     */    OrderTypeEnum getOrderType(){        return OrderTypeEnum.Ring;    }
}
public class CmdFactory {    private List<OrderHandler> orderHandlerList;
    /**     * 获取指定指令条件的指令对象     *     * @param command     * @return     */     public PipelineCmd getPipelineCmd(Command command) {        for (OrderHandler orderHandler : orderHandlerList) {            OrderTypeEnum orderTypeEnum = orderHandler.getOrderType();            if (orderTypeEnum.equals(command.getOrder())) {                return new ZhuChiCmd(command, orderHandler);            }        }        throw new RuntimeException("对不起主持：没有多余的和尚来执行新命令了！");    }     /**     * 获取给定指令的回滚操作指令对象     *     * @param command     * @return     */    public PipelineCmd getRollbackPipelineCmd(Command command) {        Command rollbackCommand = getRollbackCommand(command);        return getPipelineCmd(rollbackCommand);    }}

public class CmdHandlerImpl implements CmdHandler {    private CmdFactory cmdFactory;
    @Override    public PipeResult execute(CallContext callContext) {        PipelineCmd pipelineCmd = cmdFactory.getPipelineCmd(callContext.getCommand());        PipeResult pipeResult = pipelineCmd.execute(callContext.getPipeContext());        return pipeResult;    }
    @Override    public PipeResult rollback(CallContext callContext) {        Command rollbackCommand = cmdFactory.getRollbackCommand(callContext.getCommand());        if (rollbackCommand == null) {            return new PipeResult("不需要回滚");        }        PipelineCmd pipelineCmd = cmdFactory.getPipelineCmd(rollbackCommand);        if (!pipelineCmd.isReversible()) {            return new PipeResult("不支持回滚");        }        PipeResult pipeResult = pipelineCmd.execute(callContext.getPipeContext());        return pipeResult;    }
    @Override    public PipeResult rollbackAll(PipeContext pipeContext) {        // 命令执行备忘录模式对象,这里不再展开        Caretaker<Command> caretaker = pipeContext.getCaretaker();        // 拿到上一步执行命令，依次循环回滚       Command command = caretaker.pop();        while (command != null) {            PipelineCmd pipelineCmd = cmdFactory.getRollbackPipelineCmd(command);            if (pipelineCmd != null) {                pipelineCmd.execute(pipeContext);            }            command = caretaker.pop();        }        return new PipeResult();    }
}

求分享