策略模式的介绍

已于 2023-06-15 15:53:01 修改
阅读量3w 收藏 2
点赞数 2
分类专栏： 设计模式 文章标签： 策略模式 java
于 2023-06-11 15:10:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25409421/article/details/131153423
版权
策略模式是一种设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。这种模式使得算法可以在不修改客户端代码的情况下独立变化。文章通过代码示例展示了如何创建抽象策略、具体策略和上下文类，并解释了其优点和缺点，如易于扩展、提高代码可读性，但需要额外的类和接口。最后，文章给出了一个优化if-else结构的审计策略应用实例。
摘要由CSDN通过智能技术生成

什么是策略模式

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

 

策略模式结构

1）抽象策略（Strategy）类：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有具体策略类所需的接口。

2）具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现或行为。

3）环境或上下文（Context）类：是使用算法的角色，持有一个策略类的引用，最终给客户端调用。

代码示例：

package main.java.cn.test.strategy.V1;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:28:43
 * @description
 */
public interface Strategy {
    void algorithm();
}

package main.java.cn.test.strategy.V1;

import main.java.cn.test.strategy.V1.Strategy;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:29:10
 * @description
 */
public class ConcreteStrategyA implements Strategy {
    @Override
    public void algorithm(){
        System.out.println("执行策略A");
    }
}

package main.java.cn.test.strategy.V1;

import main.java.cn.test.strategy.V1.Strategy;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:29:49
 * @description
 */
public class ConcreteStrategyB implements Strategy {
    @Override
    public void algorithm() {
        System.out.println("执行策略B");
    }
}

package main.java.cn.test.strategy.V1;

import main.java.cn.test.strategy.V1.Strategy;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:30:13
 * @description
 */
public class Context {
    private Strategy strategy;

    public Context(Strategy strategy){
        this.strategy = strategy;
    }
    // 调用策略类中的算法
    public void algorithm(){
        strategy.algorithm();
    }
}

package main.java.cn.test.strategy.V1;

import main.java.cn.test.strategy.V1.ConcreteStrategyA;
import main.java.cn.test.strategy.V1.Context;
import main.java.cn.test.strategy.V1.Strategy;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:30:31
 * @description
 */
public class Client {
    public static void main(String [] args){
        Strategy strategyA = new ConcreteStrategyA();
        // 具体策略类，可以在运行时指定类型，通过配置文件+反射机制实现
        Context context = new Context(strategyA);
        context.algorithm();
    }
}

优点

1）易于扩展和维护。由于不同的算法被封装在不同的类中，所以我们可以很容易地添加新的算法或修改已有算法，而不需要修改客户端的代码。

2）提高代码的可读性。将不同的算法封装在不同的类中，使得代码更加模块化，易于理解和维护。

3）可以消除大量的条件语句。使用策略模式，我们可以将不同的算法替换成不同的类，从而消除大量的if-else语句，使得代码更加简洁和易于理解。

缺点

1）需要额外的类和接口。使用策略模式，我们需要为每个算法都创建一个独立的类，从而增加了代码的复杂度。

2）客户端需要知道所有的策略类。使用策略模式，客户端需要知道所有的策略类，以便在运行时选择合适的策略。这可能会增加代码的复杂度。

应用场景

1）需要根据不同的条件选择不同的算法时。例如，计算器程序需要根据用户输入的运算符选择相应的计算方法。

2）需要在运行时动态地选择算法时。例如，某个系统需要根据用户的配置或环境变量来选择合适的算法。

3）需要将算法的实现细节与客户端代码分离时。例如，某个系统需要根据不同的数据来源来解析数据，但是客户端并不关心数据的解析细节。

应用：策略模式优化if-else代码

package main.java.cn.test.strategy.V2;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:34:56
 * @description 定义策略接口
 */
public interface AuditStrategy {
    // 判断条件是否匹配
    public boolean isSupport(LeaveForm leaveForm);

    // 审核业务逻辑
    public void audit(LeaveForm leaveForm);

    // 规则冲突优先级
    public int getPriority();

    // 规则名称
    public String getName();
}

package main.java.cn.test.strategy.V2;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:35:56
 * @description 策略实现1
 */
public class AuditStrategyImpl_1 implements AuditStrategy{
    @Override
    public boolean isSupport(LeaveForm leaveForm) {
        return leaveForm.getDays() <= 3 && leaveForm.getType() == 1;
    }
    @Override
    public void audit(LeaveForm leaveForm) {
        System.out.println(leaveForm);
        System.out.println("三天以下婚丧假 无需审批自动通过!");
    }
    @Override
    public int getPriority() {
        return 0;
    }
    @Override
    public String getName() {
        return "三天以下婚假审批规则";
    }
}

package main.java.cn.test.strategy.V2;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:36:32
 * @description 策略实现2
 */
public class AuditStrategyImpl_2 implements AuditStrategy{
    @Override
    public boolean isSupport(LeaveForm leaveForm) {
        return leaveForm.getDays() > 3 && leaveForm.getType() == 1;
    }
    @Override
    public void audit(LeaveForm leaveForm) {
        System.out.println(leaveForm);
        System.out.println("三天以上婚丧假 进入上级审批流程!");
    }
    @Override
    public int getPriority() {
        return 0;
    }
    @Override
    public String getName() {
        return "三天以上婚丧假审批规则";
    }
}

package main.java.cn.test.strategy.V2;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:36:59
 * @description 策略实现3
 */
public class AuditStrategyImpl_3 implements AuditStrategy{
    @Override
    public boolean isSupport(LeaveForm leaveForm) {
        //级别9 总经理
        return leaveForm.getEmployee().getLevle().equals(9);
    }
    @Override
    public void audit(LeaveForm leaveForm) {
        System.out.println(leaveForm);
        System.out.println("总经理请假无需审批自动通过!");
    }
    @Override
    public int getPriority() {
        return 999;
    }
    @Override
    public String getName() {
        return "总经理请假审批规则";
    }
}

package main.java.cn.test.strategy.V2;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:48:27
 * @description 策略实现4
 */
public class AuditStrategyImpl_4  implements AuditStrategy{
    @Override
    public boolean isSupport(LeaveForm leaveForm) {
        return leaveForm.getDays() > 3 && leaveForm.getType() == 0;
    }
    @Override
    public void audit(LeaveForm leaveForm) {
        System.out.println(leaveForm);
        System.out.println("三天以上病假 进入上级审批流程!");
    }
    @Override
    public int getPriority() {
        return 0;
    }
    @Override
    public String getName() {
        return "三天以上病假审批规则";
    }
}

package main.java.cn.test.strategy.V2;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:49:19
 * @description 策略实现5
 */
public class AuditStrategyImpl_5 implements AuditStrategy{
    @Override
    public boolean isSupport(LeaveForm leaveForm) {
        return leaveForm.getDays() <= 3 && leaveForm.getType() == 0;
    }
    @Override
    public void audit(LeaveForm leaveForm) {
        System.out.println(leaveForm);
        System.out.println("三天以下病假 无需审批自动通过!");
    }
    @Override
    public int getPriority() {
        return 0;
    }
    @Override
    public String getName() {
        return "三天以下病假假审批规则";
    }
}

package main.java.cn.test.strategy.V2;

import java.util.ArrayList;
import java.util.List;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:39:21
 * @description 策略工厂
 */
public class AuditStrategyFactory {
    //私有静态全局唯一 工厂对象
    private final static AuditStrategyFactory factory = new AuditStrategyFactory();
    //使用集合存储策略信息
    private List<AuditStrategy> auditStrategyList = new ArrayList<>();
    //私有构造,用于注册规则
    private AuditStrategyFactory(){
        auditStrategyList.add(new AuditStrategyImpl_1());
        auditStrategyList.add(new AuditStrategyImpl_2());
        auditStrategyList.add(new AuditStrategyImpl_3());
        auditStrategyList.add(new AuditStrategyImpl_4());
        auditStrategyList.add(new AuditStrategyImpl_5());
    }
    //全局访问点 获取单例对象
    public static AuditStrategyFactory getInstance(){
        return factory;
    }
    //获取匹配的策略
    public AuditStrategy getAuditStrategy(LeaveForm leaveForm){
        AuditStrategy auditStrategy = null;
        for (AuditStrategy strategy : auditStrategyList) {
            //找到匹配的规则
            if(strategy.isSupport(leaveForm)){
                if(auditStrategy == null){
                    auditStrategy = strategy;
                }else{
                    //优先级高的规则 替换现有的规则
                    //例如: 总经理请病假10,总经理优先级999,普通员工0

                    if(strategy.getPriority() > auditStrategy.getPriority()){
                        auditStrategy = strategy;
                    }
                }
            }
        }
        if(auditStrategy == null){
            throw new RuntimeException("没有匹配到请假审核规则");
        }else{
            return auditStrategy;
        }
    }
}

package main.java.cn.test.strategy.V2;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:40:03
 * @description 策略工厂上下文
 */
public class LeaveServiceNew {
    public void audit(LeaveForm leaveForm){
        AuditStrategyFactory factory = AuditStrategyFactory.getInstance();
        //返回符合条件的策略
        AuditStrategy strategy = factory.getAuditStrategy(leaveForm);
        //通过策略类进行审核
        strategy.audit(leaveForm);
    }
}

package main.java.cn.test.strategy.V2;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:33:53
 * @description 员工类
 */
public class Employee {


    private String name; // 姓名
    private Integer levle; // 级别

    public Employee(String name,Integer levle){
        this.name = name;
        this.levle = levle;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getLevle() {
        return levle;
    }

    public void setLevle(Integer levle) {
        this.levle = levle;
    }
}

package main.java.cn.test.strategy.V2;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:34:29
 * @description 请假实体
 */
public class LeaveForm {
    private Employee employee;//员工对象
    private String reason;//请假原因
    private int days;//天数
    private int type; //类型 0-病假 1-婚丧假 2-年假

    public LeaveForm(Employee employee,String reason,int days,int type){
       this.employee = employee;
       this.reason = reason;
       this.days = days;
       this.type = type;
    }
    public Employee getEmployee() {
        return employee;
    }

    public void setEmployee(Employee employee) {
        this.employee = employee;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public int getDays() {
        return days;
    }

    public void setDays(int days) {
        this.days = days;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }
}

package main.java.cn.test.strategy.V2;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 14:40:26
 * @description 测试类
 */
public class Client {
    public static void main(String[] args) {
        LeaveServiceNew leaveServiceNew = new LeaveServiceNew();
        LeaveForm form1 = new LeaveForm(new Employee("李总经理", 9), "甲流发烧", 10, 0);
        leaveServiceNew.audit(form1);
        LeaveForm form2 = new LeaveForm(new Employee("打工人1", 2), "甲流发烧", 2, 0);
        leaveServiceNew.audit(form2);
        LeaveForm form3 = new LeaveForm(new Employee("打工人2", 3), "结婚", 2, 1);
        leaveServiceNew.audit(form3);
        LeaveForm form4 = new LeaveForm(new Employee("打工人3", 4), "请年假,休息休息", 5, 2);
        leaveServiceNew.audit(form4);
    }
}

执行结果：

 经过上面的改造，我们已经消除了if-else的结构，每当新来了一种请假规则，只需要添加新的规则处理策略，并修改Factory中的集合。如果要使得程序符合开闭原则，则需要调整Factory中处理策略的获取方式，通过反射的方式，获取指定包下的所有Strategy实现类，然后放到字典集合中去.

夜夜流光相皎洁_小宁
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
鸭子-策略模式
02-27
这篇文章是这个系列正式开始介绍设计模式的第一篇，所以肩负着确定这个系列风格的历史重任，它在我脑袋里默默地酝酿了好多天，却只搜刮出了一点儿不太清晰的轮廓，可是时间不等人，以后再多“迭代”几次吧！...
设计模式之策略模式
12-20
1. **策略模式的介绍** 策略模式的核心思想是将算法封装到具有共同接口的独立类中，这些类被称为策略。在运行时，可以根据需要选择合适的策略对象来执行相应的算法。这样做的好处在于，它将算法的选择与使用算法的...
策略模式
寻道
11-13 6498
概述 策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。 UML 实现 Strategy.java，策略类，定义算法的公共接口。 public abstract class Strategy {    // 算法方法    public abstract void algo
java/android 设计模式学习笔记（17）---策略模式
Shawn_Dut的专栏
08-27 2458
这篇博客我们来介绍一下策略模式（Strategy Pattern，或者叫 Policy Pattern），也是行为型模式之一。通常在软件开发中，我们为了一个功能可能会设计多种算法和策略，然后根据实际使用情况动态选择对应的算法和策略，比如排序算法中的快速排序，冒泡排序等等，根据时间和空间的综合考虑进行运行时选择。 　　针对这种情况，一个常规的方法是将多种算法写在一个类中，每一个方法对应一个具体的排序
详解SpringBoot结合策略模式实战套路
08-25
在本文中，我们将详细介绍如何使用策略模式在SpringBoot项目中实现业务逻辑处理。 策略模式的定义 策略模式是一种行为设计模式，它允许开发者定义一些策略族，分别封装起来，每一个策略中的算法具有一定的独立性，...
HeadFirst策略模式
09-02
《HeadFirst策略模式》是设计模式领域的一本经典著作，其第一章主要介绍了策略模式的基本概念、原理以及在C++中的具体实现。策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。这种模式允许我们用不同的...
21.策略模式
weixin_30835923的博客
08-11 68
策略模式 一、策略模式（Strategy Pattern） 1.基本介绍 1）策略模式中，定义算法族（策略组），分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户 2）这算法体现了几个设计原则： 把变化的代码从不变的代码中分离出来 针对接口编程而不是具体类（定义了策略接口） 多用组合/聚合，少用继承（客户通过组合方式使用策略） 2.原理类图 二、应用实例 ...
23种设计模式——策略模式
两只橙的博客
08-18 2065
一、列表工具类 1、对两个列表去重并合并。 import com.google.common.collect.Lists; import com.google.common.collect.Sets; import org.apache.commons.collections4.CollectionUtils; import java.util.ArrayList; import java.ut...
策略模式——java设计模式（二十三）
qq_40369829的博客
05-18 1023
简介 结构和实现 实例 优缺点和适用范围 jdk中的应用 简介 策略模式(Strategy Pattern)：定义一系列算法并将每一个算法封装起来，让他们可以互相替换，独立于客户而变化。 用于算法的自由切换和扩展，需要使用策略模式实现算法的定义和使用分离，从而替换传统的硬编码方式。又称政策模式。 硬编码，增加算法需要修改源码，并且代码复杂，维护困难。 算法集...
走穿java23种设计模式--16策略模式详解
wenzhi的博客
02-19 575
走穿java23种设计模式–16策略模式详解策略链模式，也叫政策模式，是一种简单的模式。一.策略模式的现实场景蔡梁如愿成为了一名警察并被分配到了重案组，他刚刚调到重案组就参加了一个重大案件，这次案件需要剿灭一个贩毒团伙。因为这个贩毒团伙非常狡猾，重案组为力确保万无一失，一击即灭整个贩毒团伙，他们针对有可能发生的情况制定了多项计划，最终经过 激烈讨论他们确定了A、B、C三套计划。
策略模式（策略设计模式）详解
uzong
05-23 9407
策略模式（策略设计模式）详解 在现实生活中常常遇到实现某种目标存在多种策略可供选择的情况，例如，出行旅游可以乘坐飞机、乘坐火车、骑自行车或自己开私家车等，超市促销可以釆用打折、送商品、送积分等方法。 在软件开发中也常常遇到类似的情况，当实现某一个功能存在多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能，如数据排序策略有冒泡排序、选择排序、插入排序、二叉树排序等。...
策略模式的几种扩展用法
qq_36409043的博客
01-10 453
策略模式 + 模板方法 + 工厂模式 b站it老哥 策略模式&lambda重构策略模式 https://segmentfault.com/a/1190000021822144
opengl基础概论
weixin_43114209的博客
08-22 889
OpenGL（Open Graphics Library）是一种跨平台的图形库，用于在计算机上实现 2D 和 3D 图形。它由 Khronos Group 组织开发，是一个开放标准，可以在各种操作系统上运行，包括 Windows、Linux、macOS 和 Android。OpenGL 的主要功能是提供一组函数，用于创建和控制图形对象，例如点、线、三角形、四边形和多边形。它还提供了着色器编程，用于计算每个像素的颜色值。
开发高质量PDF应用的不二选择：PdfiumViewer库详细解析
dotnet研习社
08-19 1143
PdfiumViewer是一款基于谷歌开源PDF渲染引擎PDFium的.NET库，主要用于在Windows应用程序中显示和处理PDF文档。PdfiumViewer提供了多种API和控件，使得开发者可以轻松地将PDF文档嵌入到其应用程序中。同时，PdfiumViewer还支持多种平台，包括Windows、Linux以及MacOS。下面是一个WPF程序中使用PdfiumViewer库的完整实例。示例包含一个MainWindow窗口，其中包含一个Button控件和一个Grid控件。
工厂模式和策略模式的区别
最新发布
wypdao的专栏
08-24 156
工厂模式是一种创建型设计模式，用于定义一个接口来创建对象，但让子类决定要实例化哪个类。换句话说，工厂模式将对象的创建过程封装起来，通过一个工厂类来负责对象的创建。这种模式的核心思想是将实例化的过程延迟到子类中进行，以便于根据不同的条件或需求动态地创建对象。工厂模式可以分为三种类型：1. 简单工厂模式：通过一个工厂类的静态方法，根据传入的参数创建并返回对象实例。2. 工厂方法模式：定义一个接口用于创建对象，但让子类来决定具体实例化哪个类，具有更高的灵活性和可扩展性。
C++ 设计模式——策略模式
qq_68194402的博客
08-19 1422
引入"策略“设计模式的定义：定义一些列算法类（策略类），将每个算法封装起来，让他们可以互相替换。换句话说，策略模式通常把一系列算法封装到一系列具体策略类中作为抽象策略类的字类，然后根据实际需要适用这些字类。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值