策略模式 (Strategy Pattern)

懵萌长颈鹿2026-01-28 8:47

策略模式 (Strategy Pattern)

概述

策略模式是一种行为型设计模式，它定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。策略模式使得算法可独立于使用它的客户而变化。

意图

  • 定义一系列的算法，把它们一个个封装起来
  • 并且使它们可相互替换
  • 策略模式使得算法可独立于使用它的客户而变化

适用场景

  • 多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为
  • 需要在不同情况下使用不同的算法，或者算法还可能在将来用其他方式来实现
  • 对客户隐藏具体算法的实现细节，彼此完全独立

结构

复制代码 
┌─────────────┐          ┌─────────────┐
│   Context   │──────────>│  Strategy   │
├─────────────┤          ├─────────────┤
│ - strategy  │          │ + algorithmInterface() │
│ + contextInterface() │  └─────────────┘
└─────────────┘                  ▲
                                 │
┌─────────────┐          ┌─────────────┐
│   Client    │          │ConcreteStrategy│
├─────────────┤          ├─────────────┤
│             │          │ + algorithmInterface() │
└─────────────┘          └─────────────┘

参与者

  • Strategy：定义所有支持的算法的公共接口，Context使用这个接口来调用某ConcreteStrategy定义的算法
  • ConcreteStrategy：实现Strategy接口的具体算法
  • Context：用一个ConcreteStrategy对象来配置，维护一个对Strategy对象的引用，可以定义一个接口让Strategy访问它的数据

示例代码

下面是一个完整的策略模式示例，以支付方式为例：

java 复制代码 
// Strategy - 策略接口
public interface PaymentStrategy {
    void pay(int amount);
}

// ConcreteStrategy - 具体策略1
public class CreditCardPayment implements PaymentStrategy {
    private String name;
    private String cardNumber;
    private String cvv;
    private String dateOfExpiry;
    
    public CreditCardPayment(String name, String cardNumber, String cvv, String dateOfExpiry) {
        this.name = name;
        this.cardNumber = cardNumber;
        this.cvv = cvv;
        this.dateOfExpiry = dateOfExpiry;
    }
    
    @Override
    public void pay(int amount) {
        System.out.println(amount + " 元使用信用卡支付");
        System.out.println("持卡人: " + name);
        System.out.println("信用卡号: " + cardNumber);
        System.out.println("CVV: " + cvv);
        System.out.println("有效期: " + dateOfExpiry);
        System.out.println("支付成功！");
    }
}

// ConcreteStrategy - 具体策略2
public class AlipayPayment implements PaymentStrategy {
    private String email;
    private String password;
    
    public AlipayPayment(String email, String password) {
        this.email = email;
        this.password = password;
    }
    
    @Override
    public void pay(int amount) {
        System.out.println(amount + " 元使用支付宝支付");
        System.out.println("支付宝账号: " + email);
        System.out.println("支付成功！");
    }
}

// ConcreteStrategy - 具体策略3
public class WeChatPayment implements PaymentStrategy {
    private String phoneNumber;
    
    public WeChatPayment(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
    
    @Override
    public void pay(int amount) {
        System.out.println(amount + " 元使用微信支付");
        System.out.println("微信绑定手机号: " + phoneNumber);
        System.out.println("支付成功！");
    }
}

// Context - 上下文类
public class ShoppingCart {
    private PaymentStrategy paymentStrategy;
    private int totalAmount;
    
    public ShoppingCart(int totalAmount) {
        this.totalAmount = totalAmount;
    }
    
    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }
    
    public void checkout() {
        System.out.println("购物车总金额: " + totalAmount + " 元");
        paymentStrategy.pay(totalAmount);
    }
}

// Client - 客户端
public class Client {
    public static void main(String[] args) {
        // 创建购物车
        ShoppingCart cart = new ShoppingCart(1000);
        
        // 选择支付方式
        cart.setPaymentStrategy(new CreditCardPayment("张三", "1234567890123456", "123", "12/25"));
        cart.checkout();
        
        System.out.println();
        
        // 更换支付方式
        cart.setPaymentStrategy(new AlipayPayment("zhangsan@example.com", "password123"));
        cart.checkout();
        
        System.out.println();
        
        // 再次更换支付方式
        cart.setPaymentStrategy(new WeChatPayment("13800138000"));
        cart.checkout();
    }
}

另一个示例 - 排序算法

java 复制代码 
// Strategy - 策略接口
public interface SortStrategy {
    void sort(int[] array);
}

// ConcreteStrategy - 具体策略1
public class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("使用冒泡排序");
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // 交换 array[j] 和 array[j+1]
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

// ConcreteStrategy - 具体策略2
public class SelectionSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("使用选择排序");
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换 array[minIndex] 和 array[i]
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
    }
}

// ConcreteStrategy - 具体策略3
public class InsertionSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("使用插入排序");
        int n = array.length;
        for (int i = 1; i < n; i++) {
            int key = array[i];
            int j = i - 1;
            
            // 将 array[0..i-1] 中大于 key 的元素向后移动
            while (j >= 0 && array[j] > key) {
                array[j + 1] = array[j];
                j = j - 1;
            }
            array[j + 1] = key;
        }
    }
}

// Context - 上下文类
public class Sorter {
    private SortStrategy sortStrategy;
    
    public Sorter(SortStrategy sortStrategy) {
        this.sortStrategy = sortStrategy;
    }
    
    public void setSortStrategy(SortStrategy sortStrategy) {
        this.sortStrategy = sortStrategy;
    }
    
    public void sort(int[] array) {
        sortStrategy.sort(array);
    }
    
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}

// Client - 客户端
public class Client {
    public static void main(String[] args) {
        int[] array1 = {64, 34, 25, 12, 22, 11, 90};
        int[] array2 = {64, 34, 25, 12, 22, 11, 90};
        int[] array3 = {64, 34, 25, 12, 22, 11, 90};
        
        Sorter sorter = new Sorter(new BubbleSort());
        System.out.println("原始数组:");
        Sorter.printArray(array1);
        sorter.sort(array1);
        System.out.println("排序后数组:");
        Sorter.printArray(array1);
        
        System.out.println();
        
        sorter.setSortStrategy(new SelectionSort());
        System.out.println("原始数组:");
        Sorter.printArray(array2);
        sorter.sort(array2);
        System.out.println("排序后数组:");
        Sorter.printArray(array2);
        
        System.out.println();
        
        sorter.setSortStrategy(new InsertionSort());
        System.out.println("原始数组:");
        Sorter.printArray(array3);
        sorter.sort(array3);
        System.out.println("排序后数组:");
        Sorter.printArray(array3);
    }
}

使用Java 8函数式接口实现策略模式

java 复制代码 
import java.util.function.Function;

// Context - 上下文类
public class FunctionalSorter {
    private Function<int[], int[]> sortFunction;
    
    public FunctionalSorter(Function<int[], int[]> sortFunction) {
        this.sortFunction = sortFunction;
    }
    
    public void setSortFunction(Function<int[], int[]> sortFunction) {
        this.sortFunction = sortFunction;
    }
    
    public int[] sort(int[] array) {
        return sortFunction.apply(array);
    }
    
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}

// Client - 客户端
public class Client {
    public static void main(String[] args) {
        int[] array1 = {64, 34, 25, 12, 22, 11, 90};
        int[] array2 = {64, 34, 25, 12, 22, 11, 90};
        int[] array3 = {64, 34, 25, 12, 22, 11, 90};
        
        // 使用Lambda表达式实现冒泡排序
        FunctionalSorter sorter1 = new FunctionalSorter(array -> {
            System.out.println("使用冒泡排序");
            int n = array.length;
            int[] result = array.clone();
            for (int i = 0; i < n - 1; i++) {
                for (int j = 0; j < n - i - 1; j++) {
                    if (result[j] > result[j + 1]) {
                        int temp = result[j];
                        result[j] = result[j + 1];
                        result[j + 1] = temp;
                    }
                }
            }
            return result;
        });
        
        // 使用方法引用实现选择排序
        FunctionalSorter sorter2 = new FunctionalSorter(Client::selectionSort);
        
        // 使用Lambda表达式实现插入排序
        FunctionalSorter sorter3 = new FunctionalSorter(array -> {
            System.out.println("使用插入排序");
            int n = array.length;
            int[] result = array.clone();
            for (int i = 1; i < n; i++) {
                int key = result[i];
                int j = i - 1;
                
                while (j >= 0 && result[j] > key) {
                    result[j + 1] = result[j];
                    j = j - 1;
                }
                result[j + 1] = key;
            }
            return result;
        });
        
        System.out.println("原始数组:");
        FunctionalSorter.printArray(array1);
        int[] sorted1 = sorter1.sort(array1);
        System.out.println("排序后数组:");
        FunctionalSorter.printArray(sorted1);
        
        System.out.println();
        
        System.out.println("原始数组:");
        FunctionalSorter.printArray(array2);
        int[] sorted2 = sorter2.sort(array2);
        System.out.println("排序后数组:");
        FunctionalSorter.printArray(sorted2);
        
        System.out.println();
        
        System.out.println("原始数组:");
        FunctionalSorter.printArray(array3);
        int[] sorted3 = sorter3.sort(array3);
        System.out.println("排序后数组:");
        FunctionalSorter.printArray(sorted3);
    }
    
    // 选择排序方法
    private static int[] selectionSort(int[] array) {
        System.out.println("使用选择排序");
        int n = array.length;
        int[] result = array.clone();
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (result[j] < result[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = result[minIndex];
            result[minIndex] = result[i];
            result[i] = temp;
        }
        return result;
    }
}

优缺点

优点

  1. 策略模式提供了管理相关的算法族的办法，策略类的等级结构定义了一个算法或行为族，恰当使用继承可以把公共的代码移到父类里面，从而避免代码重复
  2. 策略模式提供了可以替换继承关系的办法，继承可以处理多种算法或行为，如果不使用策略模式，那么使用算法或行为的环境类就可能会有一些子类，每一个子类提供一个不同的算法或行为，但是，这样一来算法或行为的使用者就和算法或行为本身混在一起，决定使用哪一种算法或采取哪一种行为的逻辑就和算法或行为的逻辑混合在一起，从而不可能再独立演化，继承使得动态改变算法或行为变得不可能
  3. 策略模式可以避免使用多重条件转移语句，多重转移语句不易维护，它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起，统统列在一个多重转移语句里面，比使用继承的办法还要原始和落后

缺点

  1. 客户端必须知道所有的策略类，并自行决定使用哪一个策略类，这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类
  2. 策略模式造成很多的策略类，每一个具体策略类都会产生一个新类，有时候可以通过使用享元模式来减少对象的数量

相关模式

  • 状态模式：状态模式和策略模式的结构相似，但状态模式强调的是对象在不同状态下的行为，而策略模式强调的是算法的替换
  • 模板方法模式：模板方法模式和策略模式都用于封装算法，但模板方法模式使用继承来改变算法的部分，而策略模式使用组合来改变整个算法
  • 工厂模式：工厂模式可以用来创建策略对象

实际应用

  • Java中的Comparator接口
  • Spring框架中的Resource接口
  • 数据库连接池中的负载均衡策略
  • 缓存系统中的替换策略
  • 图像处理中的滤镜效果

策略模式与状态模式的区别

  • 策略模式：策略模式中的策略对象通常是相互独立的，客户端可以选择不同的策略
  • 状态模式：状态模式中的状态对象通常是有联系的，状态之间可以相互转换

策略模式关注的是算法的替换和封装，而状态模式关注的是对象在不同状态下的行为变化。

注意事项

  1. 策略模式中的策略对象应该是轻量级的，不应该包含过多的状态信息
  2. 策略模式中的策略对象应该是可共享的，可以考虑使用享元模式来优化性能
  3. 策略模式中的策略对象应该是可扩展的，可以方便地添加新的策略
  4. 策略模式中的策略对象应该是可配置的，可以通过配置文件来选择不同的策略
相关推荐
意法半导体STM3215 天前
【官方原创】如何为STM32CubeMX2配置Visual Studio Code配置方案
vscode·stm32·单片机·嵌入式硬件·策略模式·stm32cubemx·嵌入式开发
山东点狮信息科技有限公司15 天前
企业级 MES 制造执行系统架构设计与实践
spring cloud·性能优化·系统架构·策略模式·点狮
zzqssliu15 天前
基于策略模式与责任链的代购商品多源采集架构实战
架构·策略模式
mxpan16 天前
macOS 13+ 上使用 macFUSE + NTFS-3G 读写 NTFS 移动硬盘技术说明
macos·策略模式
折哥的程序人生 · 物流技术专研17 天前
Java 23 种设计模式：从踩坑到精通 | 番外：编排器+策略模式在多平台电子面单中的实战（含性能压测）
设计模式·策略模式·代码重构·java设计模式·编排器·电子面单·从踩坑到精通
忧云17 天前
2026年最新 Cursor 国内使用 DeepSeek API等各模型使用完整教程
ai编程·策略模式·cursor·byok·cursor使用国内大模型
AIex-YH18 天前
三域贯通11/12：生物制造的“死亡之谷“，CDMO 是桥还是船？
运维·制造·策略模式
回忆2012初秋18 天前
【Nginx】原理、配置与运维实战（2）
运维·nginx·策略模式
怎么没有名字注册了啊19 天前
macOS 基于 CSDN GitCode + Homebrew Tap 发布 Qt .app 二进制程序通用教程（homebrew 安装自己的软件）
策略模式·homebrew·formula·ruhy
坏小虎20 天前
macOS 安装 Ghostty 终端完整教程：环境、依赖与美化配置
macos·策略模式
热门推荐
012026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf022026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？032026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？04Trae国际版与国内版深度测评：AI原生IDE的双生花05GitHub 镜像站点06飞书长连接_事件订阅（接收消息，审批任务状态变更）07【AI】2026 年具身智能模型和世界模型总结08Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析092026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？102026年AI架构实战：彻底解决OpenAI接口超时与封号，Python调用GPT-5.2/Sora2企业级架构详解（附源码+压测报告）