设计模式伪代码

傷城~ 2023-01-04 13:24 79阅读 0赞

### 策略模式与简单工厂模式结合 ###

*  两者结合的好处是，用户只需认识一个类。这样**其它代码和价格代码耦合就更低了**
 *  简单工厂模式（参数化工厂模式）
 *  简单工厂模式和工厂模式的区别
    
     *  工厂模式把内部判断逻辑交给了客户端，需要客户端来选择具体子工厂
     *  简单工厂是对工厂模式的包装，包装了客户端的判断逻辑

public class CashContext { 
        CashSuper cs = null;
        
        //其实可以结合 建造者模式 来构建 CashSuper，即 300,100 0.8 这些参数可以通过 CashContextBuild 传入
        //new CashContext().withM_F(300,100).withRebate(0.8);
        //但是建造者模式如何使用？还是简单工厂模式来的简单
        public CashContext(type) { 
            //如果这里的子类没有自己的属性，那么这里的 switch 可以通过反射来替换！（dubbo spi 机制）
            switch(type) { 
                case "正常收费":
                	cs = new CashNormal();break;
                case "满 300 返 100":
                	cs = new CashReturn(300,100);break;
                case "打 8 折":
                	cs = new CashRebate(0.8);
            }
        }
        
        //这里就要考虑 money 是形参形式，还是属性
        public double GetResult(double money) { 
            return cs.acceptCash(money);
        }
    }

### 合成/聚合复用原则 ###

*  整体聚合成群体
 *  部分合成为整体  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2thbmdzYTk5OA_size_16_color_FFFFFF_t_70_pic_center]

//------------------状态模式------------------------
    //客户端操作 StateContext 对象
    //状态转移的动作应该是稳定的。但是状态是可以变化的
    public class StateContext implement actions { 
        private State state;
        public StrategyContext(State state) { 
            this.state = state;
        }
        public void action1(..) { 
            //在 state 中改变 context 的状态，也就改变了 context 的行为了
            state.action1(this);
        }
    }
    //------------------策略模式------------------------
    //客户端操作 CashContext 对象
    //策略对应的算法是变化的，但是执行的动作应该是稳定的
    public class CashContext { 
        CashSuper cs = null;
        
        //其实可以结合 建造者模式 来构建 CashSuper，即 300,100 0.8 这些参数可以通过 CashContextBuild 传入
        //new CashContext().withM_F(300,100).withRebate(0.8);
        //但是建造者模式如何使用？还是简单工厂模式来的简单
        public CashContext(type) { 
            //如果这里的子类没有自己的属性，那么这里的 switch 可以通过反射来替换！（dubbo spi 机制）
            switch(type) { 
                case "正常收费":
                	cs = new CashNormal();break;
                case "满 300 返 100":
                	cs = new CashReturn(300,100);break;
                case "打 8 折":
                	cs = new CashRebate(0.8);
            }
        }
        
        //这里就要考虑 money 是形参形式，还是属性
        public double GetResult(double money) { 
            return cs.acceptCash(money);
        }
    }
    //------------------命令模式------------------------
    //Command 的结构要保持稳定。executor 是变化的
    public abstract class Command { 
        private Executor executor;
        public Command(Executor executor) { 
            this.executor = executor;
        }
        public void action1() { 
            executor.action1();
        }
        //actionN
    }
    public class CommandContext { 
        List<Command> commands = new List<Command>();
        //封装一些commands做额外操作，因为命令可能时批量执行的，或者打日志等，或者撤销命令等
    }
    //------------------访问者模式------------------------
    //如果元素结构变动的话，可能所有的 visitor 都要变。所以要保证element是稳定的
    //Visitor 可以随意扩展变动（即，访问者模式封装的变化就是 访问者）
    public abstract class Element { 
        //关键：结构体内部就要提供被访问的接口，通过这个接口将元素本身再传递给各个vistor
        public abstract void accept(Visitor visitor){ ...}
    }
    public class ObjectStructure { 
        List<Element> elements = ...;
        //add and remove 方法
        public void accept(Visitor visitor) { 
            for (Element e : elements) { 
                e.accept(visitor);
            }
        }
    }
    //------------------备忘录模式------------------------
    //可变的是 Memento，不变的是 element
    public class element { 
        public Memento saveState() { 
            return new Memento(this);
        }
        public void Recovery(Memento memento) { 
            memento.recovery(this);
        }
    }
    public abstract class Memento<T> { 
        T t;
        abstract recovery(T t);
    }
    //对备忘进行管理
    public class MementoContext { ...}
    
    //------------------装饰者模式------------------------
    //component 不变（核心功能），Decorator 变（额外的职责）
    abstract class Decorator implement Component { 
        private Component component;
        public Decorator(Component component) { 
            this.component = component;
        }
        operation() { 
            //执行动作
            component.operation();
            //执行动作
        }
    }
    //------------------模板模式------------------------
    //逻辑框架不变（执行流程）
    abstract class Template { 
        abstract void hook1();
        abstract void operation1();
        public void templateMethod() { 
            operation1();
            hook1();
            operation2();
        }
    }
    //------------------抽象工厂、工厂模式------------------------
    //抽象工厂创建一个产品的各个部分，工厂模式创建一个完整的产品
    abstract class Factory { 
        createPizza();
    }
    abstract class abstractFactory { 
        createDough();
        createSauce();
        createCheese();
        createVeggies();
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2thbmdzYTk5OA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221119/8f2d923eef0a454ba4976b180d6573d8.png