【设计模式（21）】行为型模式之策略模式

个人学习笔记分享，当前能力有限，请勿贬低，菜鸟互学，大佬绕道

如有勘误，欢迎指出和讨论，本文后期也会进行修正和补充

现实中，对于同一个目标，我们通常有多种策略可以选择，比如出行可以乘坐飞机、乘坐火车、骑车或者自己开车等等，支付方式可以选择微信支付、支付宝、刷卡支付等等，根据实际情况我们自行选择合适的方案

开发中也是如此，对于同一功能，我们可以采取不同的算法或者策略进行实现。

比如对数据进行排序可以使用冒泡排序、选择排序、快速排序等等，对于短信服务我们可以使用腾讯、阿里、亿速等等提供的服务

如果用多重条件转移语句实现，不但使条件语句变得更加复杂，而且再进行扩展需要修改源代码，不利于维护，违背了开闭原则

策略模式则是为了解决这种问题，即允许我们灵活的切换策略

1.介绍

适用目的：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。

何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决：将这些算法封装成一个一个的类，任意地替换。

关键代码：实现同一个接口。

应用实例：排序算法的选择；短信服务的选择；Java Awt的LayoutManager；数据库的选择；

优点：

• 算法和策略可以自由切换
• 避免使用多重条件语句，易于维护
• 扩展性好

缺点：

• 策略类会增多
• 所有策略类均需要向外暴露
• 客户端必须理解所有策略算法的区别，以便选择合适的策略类

注意：可以恰当使用继承，来讲重复的代码转移到父类中，进而缩小策略类的复杂度

2.结构

策略类的主要角色如下：

• 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
• 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
• 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

3.步骤

1. 构建抽象策略类

   //抽象策略类
   interface Strategy {
       public void strategyMethod();    //策略方法
   }
   

2. 构建具体策略类

   //具体策略类A
   class ConcreteStrategyA implements Strategy {
       public void strategyMethod() {
           System.out.println("具体策略A的策略方法被访问！");
       }
   }
   
   //具体策略类B
   class ConcreteStrategyB implements Strategy {
       public void strategyMethod() {
           System.out.println("具体策略B的策略方法被访问！");
       }
   }
   

3. 构建环境类

   //环境类
   class Context {
       private Strategy strategy;
   
       public Strategy getStrategy() {
           return strategy;
       }
   
       public void setStrategy(Strategy strategy) {
           this.strategy = strategy;
       }
   
       public void strategyMethod() {
           strategy.strategyMethod();
       }
   }
   

测试代码

public class StrategyTest {
    public static void main(String[] args) {
        Context c = new Context();
        Strategy strategyA = new ConcreteStrategyA();
        c.setStrategy(strategyA);
        c.strategyMethod();
        System.out.println("-----------------");
        Strategy strategyB = new ConcreteStrategyB();
        c.setStrategy(strategyB);
        c.strategyMethod();
        System.out.println("-----------------");
    }
}

运行结果

4.扩展

当策略模式中的策略过多时，整个系统会变得很臃肿，那么我们可以使用策略工厂模式减少客户端的工作复杂度

实现代码如下

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

public class StrategyFactoryTest {
    public static void main(String[] args) {
        StrategyFactory factory=new StrategyFactory();
        factory.put("A",new ConcreteStrategyA());
        factory.put("B",new ConcreteStrategyB());
        factory.strategyMethod("A");
        System.out.println("-----------------");
        factory.strategyMethod("B");
        System.out.println("-----------------");
    }
}

//抽象策略类
interface Strategy {
    public void strategyMethod();    //策略方法
}

//具体策略类A
class ConcreteStrategyA implements Strategy {
    public void strategyMethod() {
        System.out.println("具体策略A的策略方法被访问！");
    }
}

//具体策略类B
class ConcreteStrategyB implements Strategy {
    public void strategyMethod() {
        System.out.println("具体策略B的策略方法被访问！");
    }
}

//策略工厂类
class StrategyFactory {
    private Map<String, Strategy> strategyMap = new HashMap<>();

    public Strategy get(String key) {
        return strategyMap.getOrDefault(key, null);
    }

    public void put(String key, Strategy strategy) {
        strategyMap.put(key, strategy);
    }

    public void strategyMethod(String key) {
        strategyMap.getOrDefault(key, null).strategyMethod();
    }
}

后记

策略模式的目的在于自己灵活的切换策略，同时使用继承和工厂模式更进一步增加灵活性，个人还是挺喜欢这种模式的~

---

作者：Echo_Ye

WX：Echo_YeZ

Email ：echo_yezi@qq.com

个人站点：在搭了在搭了。。。（右键 - 新建文件夹）