精华内容
下载资源
问答
  • 策略设计模式
    千次阅读
    2019-02-12 17:30:29

    定义:策略模式定义了一系列的算法,并将每一个算法封装起来,而且使他们可以相互替换,让算法独立于使用它的客户而独立变化。

    这个模式涉及到三个角色:

    环境(Context)角色:持有一个Strategy的引用。

    抽象策略(Strategy)角色:这是一个抽象角色,通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

    具体策略(ConcreteStrategy)角色:包装了相关的具体算法或行为。

    策略模式的典型代码如下:

    ①策略接口:

    /**
     * 策略 接口
     */
    public interface Strategy {
    
        /**
         * 策略方法
         */
        void strategyInterface();
    }

    ②具体策略:

    public class ConcreateStrategyA implements Strategy {
    
        @Override
        public void strategyInterface() {
            //do something
        }
    }
    
    public class ConcreateStrategyB implements Strategy {
        @Override
        public void strategyInterface() {
            //do something
        }
    }

    ③环境(Context)

    public class Content {
        private Strategy strategy;
    
        public Content(Strategy strategy){
            this.strategy=strategy;
        }
        /**
         * 策略方法
         */
        public void contextInterface(){
    
            strategy.strategyInterface();
        }
    }

    具体使用示例:

    针对不同会员等级,商品折扣不相同,普通打9.5折,会员打9折。

    策略:

    public interface Strategy {
    
        /**
         * 策略方法
         */
        void strategyPrice(Double price);
    }

    具体策略:

    public class UserStrategy implements Strategy {
    
        @Override
        public Double strategyPrice(Double price) {
            price=price*0.95;
            return price;
        }
    }
    
    public class VipUserStrategy implements Strategy {
    
        @Override
        public Double strategyPrice(Double price) {
            price=price*0.90;
            return price;
        }
    }

    环境:

    public class Content {
        private Strategy strategy;
    
        public Content(String  userType){
            if(userType=="user"){
                this.strategy= new UserStrategy();
            }
            if(userType=="vip"){
                this.strategy= new VipUserStrategy();
            }
            
        }
        /**
         * 策略方法
         */
        public void contextInterface(Double price){
    
            strategy.strategyPrice(price);
        }
    }

    具体客户端:

    new Content("vip").contextInterface(19.88);

    new Content("user").contextInterface(19.88);

     策略设计模式与Spring整合

    @Component
    public class Content {
    
        @Autowired 
        Map<String, Strategy> strategyMap = new ConcurrentHashMap<>(); 
       
        
        /**
         * 策略方法
         */
        public void getStrategy(String userType){
    
            strategyMap.get(userType).strategyPrice();
        }
    }

    更多相关内容
  • 设计模式策略模式

    千次阅读 2022-01-27 13:31:11
    java程序的设计原则 6大原则: 单一职责:一个类和方法只做一件事。 开闭:对修改关闭,对扩展开发。...策略设计模式一般使用的场景是,多种可互相替代的同类行为,在具体运行过程中根据不同情况,选择其中

    源码

    java程序的设计原则

    6大原则:

    单一职责:一个类和方法只做一件事。
    开闭原则:对修改关闭,对扩展开发。
    里氏替换原则:子类可扩展新方法,但不可修改父类已有方法(父类已提供了具体实现的方法)。
    依赖倒置:依赖于抽象,而非具体实现,即面向接口编程(如方法参数,类属性使用接口声明,这样可接收任何子类)。
    接口隔离:使用多个隔离的接口定义抽象,降低耦合。
    最少知道/迪米特原则:降低类之间的依赖,聚合,组合等。
    

    1:策略设计模式

    策略设计模式一般使用的场景是,多种可互相替代的同类行为,在具体的运行过程中根据不同的情况,选择其中一种行为来执行,比如支付,有微信支付,支付宝支付,银行卡支付,那么到底使用哪种支付方式,这是由用户来决定的,再比如购物优惠,用户可以选择使用优惠券,可以选择满减优惠,以及其他优惠方式,到底是使用优惠券,还是满减,或者其他优惠方式,还是由用户来决定,类似的场景我们都可以考虑使用策略设计模式,可能对于类似的场景我们最常用的还是ifelse,ifelse的缺点是缺少扩展性,从6大原则来说不符合开闭原则,下面我们通过一个实际的场景来看下策略设计模式如何使用。

    策略模式的UML图如下:

    在这里插入图片描述

    1.1:场景

    在这里插入图片描述

    在我们购物时经常会有如图中的优惠活动:

    直减:比如在双十一等时间,商家会选择这种方式进行促销,如原价999的商品,直接降价到899。
    满减:一般以券的方式发放给用户,当用户消费金额达到一定数目时,直接使用券来抵扣一定额度的现在,如图中“满2000减1000”,总价2999,用券后需要2899。
    折扣:商家直接打折出售商品,如原价1000元的商品,直接八折出售,实际价格为800元。
    N元购:另外一种营销手段,比如1元购1999元的手机,但是并非百分百可购得,而是有一定概率,类似于买彩票。
    

    了解了以上的几种优惠活动,

    下面我们先来看下通过常规的if-else如何实现,具体参考1.2:if-else实现

    1.2:if-else实现

    示例代码如下,用于计算用户实际需要支付的金额(仅仅示例,并没有提供真正实现)

    class FakeCls {
        // type: 优惠方式
        // 1:直减 2:满减:3:折扣:4:N元购
        double needPayAmount(int type, String otherParams) {
            if (type == 1) {
                // 直减相关逻辑
            } else if (type == 2) {
                // 满减相关逻辑
            } else if (type == 3) {
                // 折扣相关逻辑
            } else if (type == 4) {
                // N元购相关逻辑
            }
        }   
    }
    

    以上的代码,很明显不符合6大涉及原则中的单一职责开闭原则(注意并不是默认其他原则都符合),这样写代码扩展性很弱,修改代码的成本高,对现有功能的影响大(说不定你一行代码的修改,老功能都不好用了,你说是让测试测还是不测,不测吧,很明显被影响了,测吧,又会增加人家的工作量),接下来我们看下如何使用策略设计模式来优化代码。

    1.3:策略设计模式实现

    首先根据依赖倒置原则,我们需要一个接口,如下:

    public interface PayAmountStrategy {
        double payAmount(Object param);
    }
    

    再根据单一职责原则,我们分别为每种优惠策略提供一个具体实现类。

    • 直减
    // 直减
    public class DecreasePayAmountStrategy implements PayAmountStrategy {
        @Override
        public double payAmount(Object param) {
            System.out.println("使用直减方式支付");
            return 0;
        }
    }
    
    • 满减
    // 满减
    public class CouponPayAmountStrategy implements PayAmountStrategy {
        @Override
        public double payAmount(Object param) {
            System.out.println("使用满减支付");
            return 0;
        }
    }
    
    • 折扣
    // 折扣
    public class DiscountPayAmountStrategy implements PayAmountStrategy {
        @Override
        public double payAmount(Object param) {
            System.out.println("使用折扣方式支付");
            return 0;
        }
    }
    
    • N元购
    // N元购
    public class NYuanPayAmountStrategy implements PayAmountStrategy {
    
        @Override
        public double payAmount(Object param) {
            System.out.println("使用N元购支付");
            return 0;
        }
    }
    

    接下来定义Context类:

    public class PayAmountContext {
        // 依赖倒置原则,面向接口编程
        // 客户端需要设置自己想要使用的具体策略类,因此需要客户端对策略类有具体的了解,这点也是策略设计模式的不足之处
        private PayAmountStrategy payAmountStrategy;
    
        public PayAmountContext(/*PayAmount payAmount*/) {
            /*this.payAmount = payAmount;*/
        }
    
        public void setPayAmount(PayAmountStrategy payAmountStrategy) {
            this.payAmountStrategy = payAmountStrategy;
        }
    
        public double payAmount(Object param) {
            return this.payAmountStrategy.payAmount(param);
        }
    }
    

    此时将我们的类映射到策略设计模式UML图如下:

    在这里插入图片描述

    • 测试
    public class StrategyClient {
        public static void main(String[] args) {
            PayAmountContext payAmountContext = new PayAmountContext();
            // 使用直减策略
            payAmountContext.setPayAmount(new DecreasePayAmountStrategy());
            payAmountContext.payAmount(null);
            // 使用N元购策略
            payAmountContext.setPayAmount(new NYuanPayAmountStrategy());
            payAmountContext.payAmount(null);
            // 使用满减策略
            payAmountContext.setPayAmount(new CouponPayAmountStrategy());
            payAmountContext.payAmount(null);
            // 使用折扣策略
            payAmountContext.setPayAmount(new DiscountPayAmountStrategy());
            payAmountContext.payAmount(null);
        }
    }
    

    运行:

    使用直减方式支付
    使用N元购支付
    使用满减支付
    使用折扣方式支付
    

    在实际工作中,不一定非得按照这种方式来做,也可以根据实际的情况进行变化和调整,但是是不变的。另外我们看到具体策略类还需要交给客户端来实例化,如果具体实例也能够做到对客户端透明就更好了,接下来我们一起看下如何实现。

    1.4:基于注解和约定标记优化

    在实际开发过程中,对于不同的支付方式,我们肯定都是会和客户端来约定标记来标示当前用户选择的是哪种支付方式的,那么就可以在标记上来做文章,做法具体是,首先定义一个注解,然后将该注解定义在具体的实现类上来和前端的标记对应起来,这样就能知道哪种支付方式方式对应的具体实现类是哪个了,因此我们先来定义这个注解,如下:

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Key {
        String payType();
    }
    

    假定约定的标记和对应的支付方式如下:

    满减 -> couponPay
    直减 -> decreasePay
    折扣 -> discountPay
    N元购 -> nYuanPay
    

    然后将注解是用在具体实现类上,修改如下:

    // 满减
    @Key(payType = "couponPay")
    public class CouponPayAmountStrategy implements PayAmountStrategy {
        @Override
        public double payAmount(Object param) {
            System.out.println("使用满减支付V2");
            return 0;
        }
    }
    
    // 直减
    @Key(payType = "decreasePay")
    public class DecreasePayAmountStrategy implements PayAmountStrategy {
        @Override
        public double payAmount(Object param) {
            System.out.println("使用直减方式支付V2");
            return 0;
        }
    }
    
    // 折扣
    @Key(payType = "discountPay")
    public class DiscountPayAmountStrategy implements PayAmountStrategy {
        @Override
        public double payAmount(Object param) {
            System.out.println("使用折扣方式支付V2");
            return 0;
        }
    }
    
    // N元购
    @Key(payType = "nYuanPay")
    public class NYuanPayAmountStrategy implements PayAmountStrategy {
    
        @Override
        public double payAmount(Object param) {
            System.out.println("使用N元购支付V2");
            return 0;
        }
    }
    

    接下来使用SPI 来定义实现类:
    src/main/resources/META-INF/services/dongshi.daddy.strategy.v2.PayAmountStrategy:

    dongshi.daddy.strategy.v2.CouponPayAmountStrategy
    dongshi.daddy.strategy.v2.DecreasePayAmountStrategy
    dongshi.daddy.strategy.v2.DiscountPayAmountStrategy
    dongshi.daddy.strategy.v2.NYuanPayAmountStrategy
    

    定义简单工厂类:

    public class PayTypeFactory {
        //    private static Map<Integer, PayAmountStrategy> productMap = new HashMap<>();
        private static Map<String, PayAmountStrategy> productMap = new HashMap<>();
    
        static {
            ServiceLoader<PayAmountStrategy> load = ServiceLoader.load(PayAmountStrategy.class);
            Iterator<PayAmountStrategy> iterator = load.iterator();
            while (iterator.hasNext()) {
                PayAmountStrategy next = iterator.next();
                Class<? extends PayAmountStrategy> aClass = next.getClass();
                if (!aClass.isAnnotationPresent(dongshi.daddy.strategy.v2.Key.class))
                    throw new IllegalStateException("class: " + aClass + " expect @dongshi.daddy.strategy.v2.Key, but not found!");
    //            String payType = aClass.getAnnotation(Key.class).payType();
                productMap.put(aClass.getAnnotation(Key.class).payType(), next);
            }
        }
    
        public static PayAmountStrategy makeProduct(String payType) {
            return productMap.get(payType);
        }
    }
    

    客户端测试类:

    public class StrategyClient {
        public static void main(String[] args) {
            PayAmountContext payAmountContext = new PayAmountContext();
            /*// 使用直减策略
            payAmountContext.setPayAmount(new DecreasePayAmountStrategy());
            payAmountContext.payAmount(null);
            // 使用N元购策略
            payAmountContext.setPayAmount(new NYuanPayAmountStrategy());
            payAmountContext.payAmount(null);
            // 使用满减策略
            payAmountContext.setPayAmount(new CouponPayAmountStrategy());
            payAmountContext.payAmount(null);
            // 使用折扣策略
            payAmountContext.setPayAmount(new DiscountPayAmountStrategy());
            payAmountContext.payAmount(null);*/
            // 使用直减策略
            payAmountContext.setPayAmount(PayTypeFactory.makeProduct("decreasePay"));
            payAmountContext.payAmount(null);
            // 使用N元购策略
            payAmountContext.setPayAmount(PayTypeFactory.makeProduct("nYuanPay"));
            payAmountContext.payAmount(null);
            // 使用满减策略
            payAmountContext.setPayAmount(PayTypeFactory.makeProduct("couponPay"));
            payAmountContext.payAmount(null);
            // 使用折扣策略
            payAmountContext.setPayAmount(PayTypeFactory.makeProduct("discountPay"));
            payAmountContext.payAmount(null);
    
        }
    }
    

    运行:

    使用直减方式支付V2
    使用N元购支付V2
    使用满减支付V2
    使用折扣方式支付V2
    

    这样子,当我们系统增加了一种新的支付方式时,只需要提供具体的实现类,然后使用注解设置其标记,并将实现类定义到SPI文件中,在客户端就可以通过PayTypeFactory.makeProduct("新支付方式标记")来使用新支付方式了,符合开闭原则。

    参考文章列表

    策略模式(策略设计模式)详解

    展开全文
  • Java设计模式——策略设计模式

    万次阅读 2018-05-22 10:29:40
    上一次我们聊了简单工厂模式,让大家了解到了如何使程序具备更高的解耦性,使每一个功能代码都独立出来,今天我们和大家聊一下另一种解耦的设计模式,它就是策略设计模式。什么是策略设计模式:它定义了算法家族,...

    上一次我们聊了简单工厂模式,让大家了解到了如何使程序具备更高的解耦性,使每一个功能代码都独立出来,今天我们和大家聊一下另一种解耦的设计模式,它就是策略设计模式。

    什么是策略设计模式:它定义了算法家族,分别封装起来,让他们之间可以项目替换,此模式让算法的变化,不会影响到算法的客户。我们可以这样理解,工厂模式是让我们内部的构造变得高内聚低耦合,而策略模式是让我们的内部代码和外部客户端代码不直接进行联系,而是通过一个桥梁来进行沟通,并且使相同算法或功能的代码进行封装。给大家用UML图进行展示一下:



    大家通过上方的UML图可以看出,策略设计模式的思想为封装算法类,通过一个上下文的类,来沟通客户端和服务器端的逻辑代码。给大家代码演示一下:

    /**
     * 此类为抽象的基类,用于具体的代码来继承使用
     *
     */
    public abstract class StragerySuper {
    //算法方法,用于具体的逻辑算法来实现
    public abstract void AlphInterfact();
    }
    

    具体的实现代码类:

    /**
    *具体的算法实现代码A
    *
    **/
    class ConcreteA extends StragerySuper{
      
    @Override
    public void AlphInterfact() {
    System.out.print("算法A的实现类");
    }
    }
    

    /**
    *具体的算法实现代码B
    *
    **/
    class ConcreteB extends StragerySuper{
      
    @Override
    public void AlphInterfact() {
    System.out.print("算法B的实现类");
    }
    }
    

    /**
    *具体的算法实现代码C
    *
    **/
    class ConcreteC extends StragerySuper{
      
    @Override
    public void AlphInterfact() {
    System.out.print("算法c的实现类");
    }
    }
    

    上下文类,作为连接客户端和后台代码端的桥梁

    /**
    *Context类,用于和外界进行联系的类,用来对StrategySuper的引用
    ***/
    class Context{
    StragerySuper stragerySuper;
    public Context(StragerySuper stragerySuper){
    //初始化构造函数,传递具体的策略对象
    this.stragerySuper = stragerySuper;
    }
    //上下文接口,根据具体的策略对象,调用其算法的方法,执行具体的逻辑方法
    public void ContextInterface(){
    stragerySuper.AlphInterfact();
    }
    }
    

    客户端代码:


    /**
     *客户端代码,通过Context中间类,来实现对具体实现类的调用
     **/
    class Client{
    Context context;
    public void main(){
    //客户端通过context执行具体的逻辑代码
    context = new Context(new ConcreteA());
    context.ContextInterface();
    context = new Context(new ConcreteB());
    context.ContextInterface();
    context = new Context(new ConcreteC());
    context.ContextInterface();
    }
    }
    

    Tips:以上代码有一些是伪代码,所以大家在编译运行的时候要根据自己的实际情况进行修改,切勿直接粘贴复制!

    大家看策略模式是不是和简单工厂模式有点雷同,下面我们把两个设计模式结合起来去实现,大家会发现我们的代码会更简洁和高效,每一种设计模式不是独立,他们都是可以交叉使用的。我们只有不断的在我们的代码中去应用到这些设计模式,那么我们的编程思想会越来越灵活。

    就像上面策略模式代码中所体现的那样,我们会发现我们的客户端还是比较臃肿,生成了很多Context的类,我们能不能把策略模式和工厂模式相结合呢,在桥梁类Context中去做判断和生成不同业务逻辑相对应的业务类呢?代码如下:



    /**
    *Context类,用于和外界进行联系的类,用来对StrategySuper的引用
    ***/
    class Context{
    StragerySuper stragerySuper = null;
    public Context(String type){
    //初始化时传递类型,直接在Context类中生成相对应的实现类
    switch(type){
    case "A":
    stragerySuper = new ConcreteA();
    break;
    case "B":
    stragerySuper = new ConcreteB();
    break;
    case "C":
    stragerySuper = new ConcreteC();
    break;
    }
    }
    //上下文接口,根据具体的策略对象,调用其算法的方法,执行具体的逻辑方法
    public void ContextInterface(){
    stragerySuper.AlphInterfact();
    }
    }
    

    /**
     *客户端代码,通过Context中间类,来实现对具体实现类的调用
     **/
    class Client{
    Context context;
    public void main(){
    //在客户端,我们可以直接调用,而不用去全部生成判断了
    Context con = new Context("A");
    con.ContextInterface();
    }
    }
    

    Tips:以上代码有一些是伪代码,所以大家在编译运行的时候要根据自己的实际情况进行修改,切勿直接粘贴复制!

    这样客户端的代码是不是简洁了许多,我们把很多逻辑上的操作都封装在我们的Context类中,这样我们的客户端就看不到我们的逻辑实现,用户只需要传递他需要的类型,用户就能获取对应的结果值,对于用户来说简单直接。

    策略模式的优势不知道大家发现了没有,我们通过这两天的例子可以发现,策略模式封装了算法,封装的这些算法都是完成功能相近的功能,只是实现不一样,减少了算法类和实现类之间的耦合性。






    Good luck!

    Write by Jimmy.li










    展开全文
  • 用c++实现的headfirst策略设计模式。并附加对应的类图。
  • Java设计模式——策略模式

    万次阅读 多人点赞 2021-10-29 12:50:37
    策略模式 1.策略模式简介 策略模式策略模式是一种行为型模式,它将对象和行为分开,将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化,行为之间可以相互替换。每个if判断都可以理解...

    策略模式

    1.策略模式简介

    策略模式:策略模式是一种行为型模式,它将对象和行为分开,将行为定义为 一个行为接口具体行为的实现。策略模式最大的特点是行为的变化,行为之间可以相互替换。每个if判断都可以理解为就是一个策略。本模式使得算法可独立于使用它的用户而变化

    2.模式结构

    策略模式包含如下角色:

    • Strategy: 抽象策略类:策略是一个接口,该接口定义若干个算法标识,即定义了若干个抽象方法(如下图的algorithm())

    • Context: 环境类 /上下文类:

      • 上下文是依赖于接口的类(是面向策略设计的类,如下图Context类),即上下文包含用策略(接口)声明的变量(如下图的strategy成员变量)。
      • 上下文提供一个方法(如下图Context类中的的lookAlgorithm()方法),持有一个策略类的引用,最终给客户端调用。该方法委托策略变量调用具体策略所实现的策略接口中的方法(实现接口的类重写策略(接口)中的方法,来完成具体功能)
    • ConcreteStrategy: 具体策略类:具体策略是实现策略接口的类(如下图的ConcreteStrategyA类和ConcreteStrategyB类)。具体策略实现策略接口所定义的抽象方法,即给出算法标识的具体方法。(说白了就是重写策略类的方法!)

    在这里插入图片描述

    3.案例

    在这里插入图片描述

    1).传统实现方式

    代码

        public Double calculationPrice(String type, Double originalPrice, int n) {
    
            //中级会员计费
            if (type.equals("intermediateMember")) {
                return originalPrice * n - originalPrice * 0.1;
            }
            //高级会员计费
            if (type.equals("advancePrimaryMember")) {
                return originalPrice * n - originalPrice * 0.2;
            }
            //普通会员计费
            return originalPrice;
        }
    

    传统的实现方式,通过传统if代码判断。这样就会导致后期的维护性非常差。当后期需要新增计费方式,还需要在这里再加上if(),也不符合设计模式的开闭原则。

    2).策略模式实现

    抽象类策略

    package StrategyExercise;
    
    public interface MemberStrategy {
        // 一个计算价格的抽象方法
        //price商品的价格 n商品的个数
        public double calcPrice(double price, int n);
    }
    
    

    具体实现类

    // 普通会员——不打折
    public class PrimaryMemberStrategy implements MemberStrategy { // 实现策略
        //重写策略方法具体实现功能
        @Override
        public double calcPrice(double price, int n) {
            return price * n;
        }
    }
    
    package StrategyExercise;
    
    // 中级会员 打百分之10的折扣
    public class IntermediateMemberStrategy implements MemberStrategy{
        @Override
        public double calcPrice(double price, int n) {
            double money = (price * n) - price * n * 0.1;
            return money;
        }
    }
    
    
    package StrategyExercise;
    
    // 高级会员类 20%折扣
    public class AdvanceMemberStrategy implements MemberStrategy{
        @Override
        public double calcPrice(double price, int n) {
            double money = price * n - price * n * 0.2;
            return money;
        }
    }
    
    

    上下文类

    也叫做上下文类或环境类,起承上启下封装作用。

    package StrategyExercise;
    
    /**
     * 负责和具体的策略类交互
     * 这样的话,具体的算法和直接的客户端调用分离了,使得算法可以独立于客户端独立的变化。
     */
    
    // 上下文类/环境类
    public class MemberContext {
        // 用户折扣策略接口
        private MemberStrategy memberStrategy;
    
        // 注入构造方法
        public MemberContext(MemberStrategy memberStrategy) {
            this.memberStrategy = memberStrategy;
        }
    
        // 计算价格
        public double qoutePrice(double goodsPrice, int n){
            // 通过接口变量调用对应的具体策略
            return memberStrategy.calcPrice(goodsPrice, n);
        }
    
    }
    
    

    测试类

    package StrategyExercise;
    
    // 测试类
    public class Application {
        public static void main(String[] args) {
    
            // 具体行为策略
            MemberStrategy primaryMemberStrategy = new PrimaryMemberStrategy(); // 接口回调(向上转型)
            MemberStrategy intermediateMemberStrategy = new IntermediateMemberStrategy();
            MemberStrategy advanceMemberStrategy = new AdvanceMemberStrategy();
    
            // 用户选择不同策略
            MemberContext primaryContext = new MemberContext(primaryMemberStrategy);
            MemberContext intermediateContext = new MemberContext(intermediateMemberStrategy);
            MemberContext advanceContext = new MemberContext(advanceMemberStrategy);
    
            //计算一本300块钱的书
            System.out.println("普通会员的价格:"+ primaryContext.qoutePrice(300,1));// 普通会员:300
            System.out.println("中级会员的价格:"+ intermediateContext.qoutePrice(300,1));// 中级会员 270
            System.out.println("高级会员的价格:"+ advanceContext.qoutePrice(300,1));// 高级会员240
        }
    }
    
    

    运行结果

    普通会员的价格:300.0
    中级会员的价格:270.0
    高级会员的价格:240.0

    上述案例UML类图

    在这里插入图片描述

    4.策略模式优缺点

    1)优点

    • 策略模式提供了对“开闭原则”的完美支持,用户可以在不 修改原有系统的基础上选择算法或行为,也可以灵活地增加 新的算法或行为。

    • 策略模式提供了管理相关的算法族的办法。

    • 策略模式提供了可以替换继承关系的办法。

    • 使用策略模式可以避免使用多重条件转移语句。

    2)缺点

    • 客户端必须知道所有的策略类,并自行决定使用哪一个策略类。
    • 策略模式将造成产生很多策略类,可以通过使用享元模式在一 定程度上减少对象的数量。

    5.策略模式适用场景

    在以下情况下可以使用策略模式:

    • 如果在一个系统里面有许多类,它们之间的区别仅在于它们 的行为,那么使用策略模式可以动态地让一个对象在许多行 为中选择一种行为。
    • 一个系统需要动态地在几种算法中选择一种。
    • 如果一个对象有很多的行为,如果不用恰当的模式,这些行 为就只好使用多重的条件选择语句来实现。
    • 不希望客户端知道复杂的、与算法相关的数据结构,在具体 策略类中封装算法和相关的数据结构,提高算法的保密性与 安全性。

    在我们生活中比较常见的应用模式有:

    1、电商网站支付方式,一般分为银联、微信、支付宝,可以采用策略模式
    2、电商网站活动方式,一般分为满减送、限时折扣、包邮活动,拼团等可以采用策略模式

    在这里插入图片描述

    6.总结

    • 在策略模式中定义了一系列算法,将每一个算法封装起来,并让它们 可以相互替换。策略模式让算法独立于使用它的客户而变化,也称为 政策模式。策略模式是一种对象行为型模式。

    • 策略模式包含三个角色:环境类在解决某个问题时可以采用多种策略, 在环境类中维护一个对抽象策略类的引用实例;抽象策略类为所支持 的算法声明了抽象方法,是所有策略类的父类;具体策略类实现了在 抽象策略类中定义的算法。

    • 策略模式是对算法的封装,它把算法的责任和算法本身分割开,委派 给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的 策略类里面,作为一个抽象策略类的子类。

    • 策略模式主要优点在于对“开闭原则”的完美支持,在不修改原有系 统的基础上可以更换算法或者增加新的算法,它很好地管理算法族, 提高了代码的复用性,是一种替换继承,避免多重条件转移语句的 实现方式;其缺点在于客户端必须知道所有的策略类,并理解其区 别,同时在一定程度上增加了系统中类的个数,可能会存在很多策 略类

    • 策略模式适用情况包括:在一个系统里面有许多类,它们之间的区 别仅在于它们的行为,使用策略模式可以动态地让一个对象在许多 行为中选择一种行为;一个系统需要动态地在几种算法中选择一种; 避免使用难以维护的多重条件选择语句;希望在具体策略类中封装 算法和与相关的数据结构。

    注:如果文章有任何错误或不足,请各位大佬尽情指出,评论留言留下您宝贵的建议!如果这篇文章对你有些许帮助,希望可爱亲切的您点个赞推荐一手,非常感谢啦

    image

    展开全文
  • python设计模式策略模式

    千次阅读 2020-07-04 18:52:56
    python设计模式策略模式 大多数问题都可以使用多种方法来解决。以排序问题为例,对于以一定次序把元素放入一个列表,排序算法有很多。通常来说,没有公认最适合所有场景的算法一些不同的评判标准能帮助我们为不同...
  • js设计模式策略模式

    千次阅读 2022-01-10 09:55:07
    深入学习实际开发设计思想,提升代码质量
  • 策略模式例子代码,对不同类型的对象执行同一函数,会使用该类型自有的算法,无需指定
  • 设计模式 模板模式和策略模式

    千次阅读 2022-03-19 20:17:12
    模板模式和策略模式,有...这种类型的设计模式属于行为型模式。 例子 假设我们需要设计两款游戏,他登录账号的方式是一样的,然后开始游戏和结束游戏的行为是不一样的,那么我们可以用模板模式来实现这个逻辑。 类图
  • Springboot 使用设计模式- 策略模式

    千次阅读 多人点赞 2020-05-12 10:03:14
    直白点,什么场景我们需要使用到设计模式- 策略模式。 在平常的springboot项目里面做CRUD,我们的习惯性基本是 一个mapper,一个service,一个serviceImpl。 但是有时候会出现一种情况,就是实现类impl里面虽然...
  • 策略模式(策略设计模式)详解

    千次阅读 2019-05-23 17:30:35
    策略模式(策略设计模式)详解 在现实生活中常常遇到实现某种目标存在多种策略可供选择的情况,例如,出行旅游可以乘坐飞机、乘坐火车、骑自行车或自己开私家车等,超市促销可以釆用打折、送商品、送积分等方法。 ...
  • 设计模式策略模式详解

    千次阅读 2020-12-15 15:22:19
    策略模式 ​ 在现实生活中常常遇到实现某种目标存在多种策略可供选择的情况,例如,出行旅游可以乘坐飞机、乘坐火车或自己开私家车等,超市促销可以釆用打折、送商品、送积分等方法。 ​ 在软件开发中也常常遇到类似...
  • NULL 博文链接:https://lfl2011.iteye.com/blog/1693685
  • 策略模式与模板模式在Spring中都广泛存在: JDBCTemplate、RedisTemplate、MongoTemplate等均是典型的模板模式。 Spring MVC中各种处理handler,是典型的策略模式。 这两个模式感觉差不多,这两个模式怎么区别呢?...
  • 策略设计模式

    千次阅读 2011-09-22 22:53:21
    策略设计模式用以封装一系列算法的选择,这些算法通常被封装在一个特定的类中(Context),客户端程序可以自由选择其中的算法,使用策略设计模式的作用是支持算法之间的自由切换。下面以电子商场为普通客户和VIP客户...
  • 二、设计模式思想 1. 定义获得余额和扣除余额抽象方法 2. 策略方法分为【货币1】策略和【货币2】策略 3. 调用放Context根据传入策略执行查询和扣除方法 4. 可扩展,新增【货币3】抽奖,则只需要实现...
  • Java 设计模式策略模式

    千次阅读 2021-11-20 20:09:42
    一、了解策略模式 1.1 什么是策略模式 策略模式 (Strategy Pattern) 是指对一系列的算法定义,并将每一个算法封装起来,而且使它们还可以相互替换。此模式让算法的变化独立于使用算法的客户。 1.2 策略模式组成...
  • 代码为博客的例子,详细讲解参考:http://blog.csdn.net/lmj623565791/article/details/24116745 有问题请留言
  • 设计模式(一):策略模式

    万次阅读 多人点赞 2019-03-01 21:37:32
    设计模式(一):策略模式 本文将以一个小Demo及其新需求来分析使用策略模式的好处。 设计模式简述: 设计模式: 1.设计模式是人们在面对同类型软件工程设计问题所总结出的一些有用的经验。模式不是代码,而是某类...
  • 设计模式最佳套路—— 愉快地使用策略模式

    千次阅读 多人点赞 2020-11-18 16:20:00
    策略模式(Strategy Pattern)定义了一组策略,分别在不同类中封装起来,每种策略都可以根据当前场景相互替换,从而使策略的变化可以独立于操作者。比如我们要去某个地方,会根据距离...
  • } } 其实这就是java设计模式策略模式,只不过就是用构造函数注入到list集合中 就算以后按摩店继续增加了一种会员体系,比如黑卡用户,只需要去写一个接口的实现类,而不需要去修改以前的代码,这也没有违反系统...
  • 最实用的设计模式策略模式的快速理解
  • 主要为大家介绍了JavaScript设计模式中的策略模式,对JavaScript设计模式感兴趣的小伙伴们可以参考一下
  • 策略模式和模板模式两者都是多态的体现,其具体的讲解可参考这位大神的文章,将的很具体。 策略:https://www.cnblogs.com/jiese/p/3181099.html 模板:https://www.cnblogs.com/jiese/p/3180477.html 模板模式:...
  • 工厂模式+策略模式

    千次阅读 2022-02-14 10:00:33
    思想: 假如我们要买汽车,我们不在乎汽车的运输,组建过程。只需要告诉经销商我要哪辆车就可以了。即:所有事情都交给工厂底层去做,我只管调用。 例子: 我现在有个需求,是商品会搞活动,每个月都有不同的活动。...
  • 本文出自: 【HansChen...设计模式之模板方法模式和策略模式概述我们知道,OOP三个基本特征是:封装、继承、多态。通过继承,我们可以基于差异编程,也就是说,对于一个满足我们大部分需求的类,可以创建它的一个子类并
  • 大话设计模式——策略模式

    千次阅读 2022-04-05 22:55:24
    1)商场收银系统 import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.DefaultListModel; import javax.swing.JButton; import javax.swing.JFrame;...
  • Spring实现策略模式

    千次阅读 2021-07-17 10:07:50
    Spring实现策略模式 当程序中出现太多的if/else/switch来处理不同类型的业务时,会变得极难维护,通过策略模式可以更容易的实现业务开发。 什么是策略模式 比如说对象的某个行为,在不同场景中有不同的实现方式,...
  • 策略设计模式(Strategy)

    千次阅读 2019-06-02 23:03:25
    策略设计模式(Strategy):可以整体的替换一个算法的实现部分,能够整体的替换算法,能让我们轻松地用不同方法解决同一个问题。 1. 示例程序 举一个收银的例子,普通用户打95折,会员打8折,超级会员打6折。 ...
  • 这份文档讲诉了设计模式策略(Strategy)模式,希望可以帮助学习的人!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 457,558
精华内容 183,023
关键字:

策略设计模式