设计模式学习——策略模式

已于 2022-12-16 17:02:47 修改
阅读量205 收藏
点赞数
分类专栏： 设计模式 文章标签： java 设计模式
于 2021-04-12 15:09:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41570691/article/details/114159387
版权

策略模式的定义

策略模式是指定义了算法策略，分别封装起来，让它们之间可以互相替换，让算法的变化不会影响到使用算法的用户。

可以避免多重分支的if else 和 switch 语句。

策略模式的适用场景

1.假如系统中有很多类，而它们的区别仅在于它们的行为不同

2.一个系统需要动态地在几种算法中选择一种

3.需要屏蔽算法规则

示例1

电商经常会在节日做活动，需要根据各种节日选择不同的优惠策略：

/**
 * 优惠策略
 */
public interface IPromotionStrategy {

    /** 做优惠 */
    void doPromotion();

}
/**
 * @Description: 无优惠策略
 */
public class EmptyStrategy implements IPromotionStrategy {
    @Override
    public void doPromotion() {
        System.out.println("无活动优惠");
    }
}
/**
 * @Description: 优惠券优惠
 */
public class CouponStrategy implements IPromotionStrategy {

    @Override
    public void doPromotion() {
        System.out.println("领取优惠券，根据优惠券进行抵扣");
    }
}
/**
 * @Description: 返现优惠
 */
public class CashBackStrategy implements IPromotionStrategy {
    @Override
    public void doPromotion() {
        System.out.println("返现，直接返现到支付宝余额");
    }
}

/**
 * @Description: 团购优惠
 */
public class GroupBuyStrategy implements IPromotionStrategy {
    @Override
    public void doPromotion() {
        System.out.println("拼团成功，进行打折");
    }
}
/**
 * @Description: 优惠活动
 */
public class PromotionActivity {

    private IPromotionStrategy promotionStrategy;

    public PromotionActivity(IPromotionStrategy promotionStrategy) {
        this.promotionStrategy = promotionStrategy;
    }

    //执行活动
    public void execute(){
        promotionStrategy.doPromotion();
    }
}

public class PromotionActivityTest {

    public static void main(String[] args) {
        //六一八活动-优惠券策略
        PromotionActivity activity618 = new PromotionActivity(new CouponStrategy());
        //双十一活动-返现策略
        PromotionActivity activity1111 = new PromotionActivity(new CashBackStrategy());

        activity618.execute();
        activity1111.execute();
    }

}

当然，实际开发中并不会像上面一样写定优惠策略，而是动态地根据活动选择优惠策略。

进行优化：

    public static void main(String[] args) {
        PromotionActivity activity=null;
        
        //假如现在的活动是优惠券优惠的活动
        String activityKey = "Coupon";

        if (StringUtils.equals(activityKey,"Coupon")){
            activity=new PromotionActivity(new CouponStrategy());
        }else if (StringUtils.equals(activityKey,"CashBack")){
            activity=new PromotionActivity(new CashBackStrategy());
        }
        //......
        activity.execute();
    }

现在倒是动态分配了，但是每多一种新的优惠策略，都需要去这里的业务逻辑加if-else，还得将整套业务逻辑重新测试。程序猿又要加班了。
再次优化：

/**
 * @Description: 结合策略模式和注册式单例，将业务代码中的多个if-else判断进行优化
 */
public class PromotionStrategyFactory {

    //定义一个Map，在工厂类内部使用静态代码块在类加载时就对map进行初始化 -> 注册式单例的特征
    private static Map<String, IPromotionStrategy> PROMOTION_STRATEGY_MAP = new HashMap<String, IPromotionStrategy>();

    static {
        PROMOTION_STRATEGY_MAP.put(PromotionKey.COUPON, new CouponStrategy());
        PROMOTION_STRATEGY_MAP.put(PromotionKey.CASH_BACK, new CashBackStrategy());
        PROMOTION_STRATEGY_MAP.put(PromotionKey.GROUP_BUY, new GroupBuyStrategy());
    }

    //构造方法私有化并提供公共的静态方法访问 -> 单例的特征
    private PromotionStrategyFactory() {
    }
    //根据优惠标识获得优惠策略
    public static IPromotionStrategy getPromotionStrategy(String promotionKey) {
        IPromotionStrategy strategy = PROMOTION_STRATEGY_MAP.get(promotionKey);
        return strategy == null ? NON_PROMOTION : strategy;
    }

    //优惠标识Key
    private interface PromotionKey {
        String COUPON = "COUPON";
        String CASH_BACK = "CASH_BACK";
        String GROUP_BUY = "GROUP_BUY";
    }

    //常量-无优惠策略
    private static final IPromotionStrategy NON_PROMOTION = new EmptyStrategy();

}

public class PromotionActivityTest {
    public static void main(String[] args) {
        String promotionKey = "COUPON";
        PromotionActivity activity = new PromotionActivity(PromotionStrategyFactory.getPromotionStrategy(promotionKey));
        activity.execute();
    }
}

可以发现，再次优化后，每次增加新的优惠策略只需要增加注册式单例的私有Map，在Map中添加响应的优惠策略即可，不需要再去修改调用处的业务代码。

这种实现将原本繁杂的多重判断进行了简化，也使日后程序中业务逻辑的维护变得简单。

示例二

网购下单时我们需要选择不同的支付方式进行支付：

/**
 * @Description: 支付的抽象
 */
public abstract class Payment {

    //支付类型
    public abstract String getName();

    //查询余额
    protected abstract double queryBalance(String uid);

    //扣款支付
    public MsgResult pay(String uid,double amount){
        if (queryBalance(uid)<amount){
            return new MsgResult(500,"支付失败","余额不足");
        }
        return new MsgResult(200,"支付成功","支付金额"+amount);
    }
}

/**
 * @Description: 阿里支付
 */
public class AliPay extends Payment {
    @Override
    public String getName() {
        return "支付宝";
    }

    @Override
    protected double queryBalance(String uid) {
        return 900;
    }
}
/**
 * @Description: 京东支付
 */
public class JDPay extends Payment {
    @Override
    public String getName() {
        return "京东白条";
    }

    @Override
    protected double queryBalance(String uid) {
        return 500;
    }
}

/**
 * @Description: 银联支付
 */
public class UnionPay extends Payment {
    @Override
    public String getName() {
        return "银联支付";
    }

    @Override
    protected double queryBalance(String uid) {
        return 200;
    }
}

/**
 * @Description: 微信支付
 */
public class WechatPay extends Payment {
    @Override
    public String getName() {
        return "微信支付";
    }

    @Override
    protected double queryBalance(String uid) {
        return 700;
    }
}
/**
 * @Description: 支付状态
 */
public class PayState {
    private int code;
    private String msg;
    private Object data;

    public PayState(int code, String msg, Object data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    @Override
    public String toString() {
        return "支付状态：["+code+"]," + msg + ", 交易详情: " + data;
    }
}
/**
 * @Description: 支付策略管理器
 * 注册式单例，提前注册好各式支付方式的实例
 */
public class PayStrategy {
    public static final String ALI_PAY = "ALI_PAY";
    public static final String JD_PAY = "JD_PAY";
    public static final String UNION_PAY = "UNION_PAY";
    public static final String WECHAT_PAY = "WECHAT_PAY";
    public static final String DEFAULT_PAY = "ALI_PAY";

    private static Map<String,Payment> payStrategy = new HashMap<>();

    static{
        payStrategy.put(ALI_PAY,new AliPay());
        payStrategy.put(JD_PAY,new JDPay());
        payStrategy.put(UNION_PAY,new UnionPay());
        payStrategy.put(WECHAT_PAY,new WechatPay());
    }

    public static Payment get(String payKey){
        if (!payStrategy.containsKey(payKey)){
            return payStrategy.get(DEFAULT_PAY);
        }
        return payStrategy.get(payKey);
    }
}
public class Order {
    private String uid;

    private String orderId;

    private double amount;

    public Order(String uid, String orderId, double amount) {
        this.uid = uid;
        this.orderId = orderId;
        this.amount = amount;
    }

    /**
     * 使用PayStrategy根据支付的类型key选择支付策略
     * 不需要再在业务中写多个条件判断了
     */
    public PayState pay(String payKey){
        Payment payment = PayStrategy.get(payKey);
        System.out.println("开始使用：" + payment.getName());
        System.out.println("本次支付金额：" + amount);
        return payment.pay(uid,amount);
    }
}


/**
 * @Auther: jesses
 * @Date: 2021/4/12
 * @Description: 下单测试
 */
public class PayTest {
    public static void main(String[] args) {
        Order order = new Order("1", "202104121042001", 322.55);
        //在使用时才确定支付方式的key
        PayState payState = order.pay(PayStrategy.ALI_PAY);
        System.out.println(payState);
    }
}

策略模式在JDK中的应用

如较常用的比较器Comparator接口，就是策略模式的抽象实现：

Comparator接口有许多的实现类，在使用时常常把Comparator作为参数传入作为排序策略，比如Arrays.sort()：

以及TreeMap的构造方法：

策略模式在Spring中的应用：

比如Resource接口及其子类实现：

还有Spring的初始化也使用到了策略模式，如InstantiationStrategy类，可以发现它的一个实现类CglibSubclassingInstantiationStrategy 是继承 另一个实现类SimpleInstantiationStrategy的，

所以说策略之间还可以继承使用。

策略模式的优点

1，策略模式符合开闭原则

2，避免多重条件判断if-else语句，提高了程序的可维护性

3，策略模式对算法进行封装，提高了算法的保密性和安全性

策略模式的缺点

1，客户端必须知道所有的策略，才能自行决定使用哪一种策略

2，代码中会产生较多的策略类，增加了维护的难度

ps：设计模式就是这样，有优点也有缺点，过多使用设计模式也会增加程序的复杂度，一昧的套用设计模式并不可取，需要根据实际业务情况去应用。

Jesses.
关注
专栏目录
设计模式学习之策略模式
一个码农的博客
04-11 7万+
写代码时总会出很多的if…else，或者case。如果在一个条件语句中又包含了多个条件语句就会使得代码变得臃肿，维护的成本也会加大，而策略模式就能较好的解决这个问题，本篇博客就带你详细了解策略模式。策略模式的定义和使用场景定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，让算法独立于使用它的客户而独立变化。分析下定义，策略模式定义和封装了一系列的算法，它们是可以相互替
设计模式入门（策略模式）
weixin_45282799的博客
03-17 202
前言 今天看了一本关于设计模式的《head first》这本书，于是想将自己的想法写下来。首先我在网上了解了一下所谓的设计模式以及设计模式的原则，之后会在学习过程中敲一敲示例代码，那么现在开始学习吧！ 设计模式简介 设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多...
Leetcode:主要元素17.10（摩尔投票法，Array.sort()，HashMap，暴力双重循环）
weixin_45268534的博客
02-23 286
文章目录主要元素（17.10）1、问题描述2、求解时间、空间消耗一、暴力解法-双重for循环二、Arrays.sort()排序三、HashMap（map.getOrDefault()方法）1、步骤2、涉及到的知识点 map.getOrDefault()3、代码四、摩尔投票法（Boyer–Moore majority vote algorithm）1、算法概述2、步骤 主要元素（17.10） 1、问题描述 数组中占比超过一半的元素称之为主要元素。给定一个整数数组，找到它的主要元素。若没有，返回-1。
设计模式之【策略模式】
Janway-Win
03-29 343
什么是策略模式？策略模式适用于什么场景？有哪些开源代码用到了策略模式？让我们一起学习设计模式之【策略模式】。
Java设计模式——策略模式
热门推荐
涛涛的个人博客
10-29 9万+
策略模式 1.策略模式简介 策略模式：策略模式是一种行为型模式，它将对象和行为分开，将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化，行为之间可以相互替换。每个if判断都可以理解为就是一个策略。本模式使得算法可独立于使用它的用户而变化 2.模式结构 策略模式包含如下角色： Strategy: 抽象策略类：策略是一个接口，该接口定义若干个算法标识，即定义了若干个抽象方法（如下图的algorithm()） Context: 环境类 /上下文类： 上下文是依赖于接口的类（
JavaScript 设计模式——策略模式
Starry_Firmament的博客
12-29 2197
是一种行为设计模式，能让我们定义一系列算法，并将每种算法分别放入独立的类中，以使算法的对象能够相互替换。
设计模式——策略模式
努力努力再努力L
10-11 526
1. 模式定义和使用场景 2. 模式结构 3. 策略模式优点？ 4. 策略模式缺点？ 5. 策略模式代码实现
Java设计模式三—— 策略模式、工厂模式
JohnnyLin
06-04 564
虽然解除了CoffeStore和Coffee的耦合，但是存在以下耦合。
经典的设计模式21——策略模式
weixin_63967970的博客
06-16 1769
定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开，并委派给不同的对象对这些算法进行管理。策略算法是形同行为的不同实现。
C++设计模式02-——策略设计模式
qq_51340322的博客
08-11 1405
定义一系列算法，把它们一个个封装起来，并且使它们可互相替换(变化)。该模式使得算法可独立于使用它的客户程序(稳定)而变化(扩展，子类化)策略——普通语境下，是我们对一件事情的处理方法，由于对不同的事情我们有不同的应对方式，我们通过权衡利弊，得到合适的方案，这个过程就是挑选策略。在面向对象编程中，对于某类事务，有着不同的处理方式，将这些方式向上抽象一层就有了策略模式。这里并不是说一般的处理方式不能完成任务，而是我们的代码是面对变化的需求的，我们要让代码简单方便维护，所以才需要此类设计模式。.........
设计模式——策略模式的学习与理解
12-20
策略模式是一种行为设计模式，它的主要目的是将不同的算法或行为封装在独立的可互换的类中，使得客户端代码能够灵活地选择并使用这些算法，而无需关心它们的具体实现。这种模式遵循了几条重要的设计原则： 1. **...
java设计模式之——策略模式
04-02
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式主要通过定义一系列的算法，并将每一个算法封装起来，使它们可以互相替换，让算法独立于使用它的客户而变化。这种模式的核心是策略...
浅谈简单工作流设计——责任链模式配合策略与命令模式的实现
03-04
本文以项目中的一个工作流模块，演示责任链模式、策略模式、命令模式的组合实现！最近在做的一个项目，涉及到的是一个流程性质的需求。关于工程机械行业的服务流程：服务任务流程和备件发运流程。项目之初，需求不是...
Servlet的生命周期
wyk的博客
11-13 1327
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
Mybatis
最新发布
庸不易的博客
11-15 647
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
1112--接口
kequanrrr的博客
11-12 446
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
java加锁问题详解
qq_74056922的博客
11-14 752
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
什么是面向对象编程？什么是面向过程编程？
m0_70208894的博客
11-15 495
不同的编程范式适用于不同的场景，选择合适的范式可以提高代码的可维护性、可读性和效率。Java 和 Go 的选择反映了不同的设计哲学，Java 更加注重封装和对象的使用，而 Go 更加简洁，强调过程和函数的使用。
《设计模式》——程序员进阶必读
"这是一本关于设计模式的书籍，旨在帮助不同层次的程序员，包括初级、高级和系统分析师，提升他们的编程...通过学习这些设计模式，程序员能够提高代码质量、可维护性和可扩展性，进一步提升软件设计的能力和专业素养。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值