【02】【行为型】【聊一聊，策略模式】-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_39911996/article/details/143951932

1 概述

1.1 简介

策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，并将每种算法封装起来，使得它们可以相互替换，算法的变化不会影响到使用算法的客户端。策略模式使得算法可以在运行时动态选择，实现了算法的可配置性和灵活性。

1.2 主要角色

策略接口（Strategy）：定义所有支持的算法的公共接口。
具体策略类（Concrete Strategies）：实现策略接口的多个类，每个类封装一种具体的算法或行为。
上下文类（Context）：包含一个策略接口的引用，并通过调用策略接口的方法来执行不同的算法。

1.3 优点

开闭原则：可以在不修改客户端代码的情况下更改算法或行为。
消除条件判断：将多个条件分支转换为算法类的选择，简化代码。
职责分离：客户端不需要知道策略的细节，只需要选择合适的策略即可。

1.4 缺点

可能会引入大量的策略类，导致类的数量增加。
客户端必须了解所有的策略来选择合适的策略。

2 实现

2.1.1 类图

2.3.2 示例代码

下附示例代码与上节类图无关，类图仅对应解策略模式的主要角色供参考，这里举一个使用不同算法进行数组排序的例子

策略接口、实现类

package com.example.demo.designpattern.behavioral.example;

public interface SortStrategy {
    int[] sort(int[] chaoticArray);
}

class BubbleSortStrategy implements SortStrategy{
    @Override
    public int[] sort(int[] chaoticArray) {
        System.out.println("++++++BubbleSortStrategy++++++");
        int n = chaoticArray.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (chaoticArray[j] > chaoticArray[j + 1]) {
                    // 交换arr[j+1]和arr[j]
                    int temp = chaoticArray[j];
                    chaoticArray[j] = chaoticArray[j + 1];
                    chaoticArray[j + 1] = temp;
                }
            }
        }
        return chaoticArray;
    }
}

class SelectionSortStrategy implements SortStrategy{
    @Override
    public int[] sort(int[] chaoticArray) {
        System.out.println("++++++SelectionSortStrategy++++++");
        return chaoticArray;
    }
}

class InsertionSortStrategy implements SortStrategy{
    @Override
    public int[] sort(int[] chaoticArray) {
        System.out.println("++++++InsertionSortStrategy++++++");
        return chaoticArray;
    }
}

策略上下文类

package com.example.demo.designpattern.behavioral.example;

public class SortStrategyContext {
    private SortStrategy sortStrategy;


    public SortStrategyContext(SortStrategy sortStrategy){
        this.sortStrategy = sortStrategy;
    }


    public int[] sort(int[] chaoticArray){
        return  sortStrategy.sort(chaoticArray);
    }
}

策略工厂类

package com.example.demo.designpattern.behavioral.example;

import java.util.HashMap;
import java.util.Map;

public class SortStrategyFactory {

    private static Map<String,SortStrategy> sortStrategyMap;


    static {
        sortStrategyMap = new HashMap<>();
        // 可以通过反射自动加载SortStrategy接口的所有实现
        // 后续再有算法扩展，工厂就不用修改了，这样更符合软件设计的“开闭原则”，学习工厂模式的时候，再详细补充下该内容
        sortStrategyMap.put(BubbleSortStrategy.class.getSimpleName(),new BubbleSortStrategy());
        sortStrategyMap.put(InsertionSortStrategy.class.getSimpleName(),new BubbleSortStrategy());
        sortStrategyMap.put(SelectionSortStrategy.class.getSimpleName(),new BubbleSortStrategy());
        System.out.println(sortStrategyMap.toString());
    }

    public static SortStrategy produceSortStrategy(String strategyType){
        return sortStrategyMap.get(strategyType);
    }


}

测试类

package com.example.demo.designpattern.behavioral.example;

import java.util.Arrays;

public class SortStrategyTest {
    public static void main(String[] args) {

        int[] chaoticArray = {15,85,45,48,1,123,78,100};

        BubbleSortStrategy bubbleSortStrategy = new BubbleSortStrategy();
        SortStrategyFactory.produceSortStrategy(BubbleSortStrategy.class.getSimpleName());
        SortStrategyContext sortStrategyContext = new SortStrategyContext(bubbleSortStrategy);

        int[] sort = sortStrategyContext.sort(chaoticArray);

        System.out.println(Arrays.toString(sort));

    }
}