菜鸟之路：23种设计模式之——策略模式

╰+攻爆jí腚メ 2022-05-19 11:17 200阅读 0赞

# 什么是策略模式？ #

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

# 什么时候去使用策略模式？ #

策略模式就是用来封装算法的，但是在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

# 适用的场景？ #

1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。

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

3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

# 策略模式的优点？ #

1、策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。

2、简化了单元测试，因此每个算法都有自己的类，可以通过自己的接口单独测试。

策略模式结构图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xrcDE2MDM2NDU3NTY_size_16_color_FFFFFF_t_70][]

策略模式：

Strategy类，定义所有支持的算法的公共接口。

/**
     * 作者：LKP
     * 时间：2018/7/25
     * 抽象算法类
     */
    public abstract class Strategy {
        //算法方法
        public abstract void AlgorithmInterface();
    }

ConcreteStrategy，封装了具体的算法或行为，继承与Strategy。这里分别用ConcreteStrategyA和ConcreteStrategyB来实现。

/**
     * 作者：LKP
     * 时间：2018/7/25
     * 具体算法A
     */
    public class ConcreteStrategyA extends Strategy {
        //算法A实现方法
        @Override
        public void AlgorithmInterface() {
            System.out.println("算法A实现");
        }
    }

/**
     * 作者：LKP
     * 时间：2018/7/25
     * 具体算法B
     */
    public class ConcreteStrategyB extends Strategy {
        //算法B实现方法
        @Override
        public void AlgorithmInterface() {
            System.out.println("算法B实现");
        }
    }

Context，用一个ConcreteStrategy来进行配置，维护一个对Strategy对象的引用。

/**
     * 作者：LKP
     * 时间：2018/7/25
     * 上下文类，用来维护一个对Strategy对象的引用
     */
    public class Context {
        Strategy strategy;
        public Context(Strategy strategy){
            this.strategy = strategy;
        }
    
        //上下文接口
        public void ContextInterface(){
            strategy.AlgorithmInterface();
        }
    }

初始化时，传入具体的策略对象。

在根据具体的策略对象，调用其算法的方法。

客户端运行代码。

/**
     * 作者：LKP
     * 时间：2018/7/25
     */
    public class Client {
        public static void main(String[] args){
            Context context;
    
            context = new Context(new ConcreteStrategyA());
            context.ContextInterface();
    
            context = new Context(new ConcreteStrategyB());
            context.ContextInterface();
    
        }
    }

运行结果：

![70][]

由于实例化不同的策略，所以最终在调用context.ContextInterface();时，所获得的的结果就不尽相同。

策略模式是一种定义一些列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方法调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象。这本身并没有解除客户端需要选择判断的压力，可以将策略模式和简单工厂模式结合，选择具体来实现的职责就可以给Context来承担，最大化地减轻了客户端的职责。

策略模式和简单工厂模式的区别：

简单工厂模式：只需要发出命令，由他人去实现。

策略模式：不知要发出命令，还得由自己亲自去做。

两个的区别非常微妙,Factory是直接创建详细的对象并用该对象去运行对应的动作，而Strategy将这个操作给了Context类。没有创建详细的对象，实现的代码的进一步封装。

简单工厂模式：[https://blog.csdn.net/lkp1603645756/article/details/81021707][https_blog.csdn.net_lkp1603645756_article_details_81021707] 可前往这里阅读。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xrcDE2MDM2NDU3NTY_size_16_color_FFFFFF_t_70]: /images/20220519/35abe74a62164a039ffab5e8f5c938a7.png
[70]: /images/20220519/4a74ba042a304038b11b34c27092604f.png
[https_blog.csdn.net_lkp1603645756_article_details_81021707]: https://blog.csdn.net/lkp1603645756/article/details/81021707