GOF23设计模式之策略模式（strategy）

一、策略模式概述

　　策略模式对应于解决某一个问题的一个算法族，允许用户从该算法族中任选一种算法解决一个问题，同时可以方便的更换算法或者增加新的算法。并且由客户端决定调用哪个算法。

　　策略模式的本质：

　　　　分离算法，选择实现。

二、策略模式场景导入

　　某公司市场部在接单时根据不同的客户进行报价，可以划分为以下几种类型：

　　　　（1）新客户小批量报价

　　　　（2）新客户大批量报价

　　　　（3）老客户小批量报价

　　　　（4）老客户大批量报价

　　当遇到这种情况时，可以采用策略模式实现。

三、使用普通方式实现报价操作

 /**
  * 普通方式实现报价
  * @author CL
  *
  */
 public class TestStrategy {

     public double getPrice(String type, double price) {
         if (type.equals("新客户小批量")) {
             System.out.println("不打折！");
             return price;
         }

         if (type.equals("新客户大批量")) {
             System.out.println("打九折！");
             return price * 0.9;
         }

         if (type.equals("老客户小批量")) {
             System.out.println("打八五折！");
             return price * 0.85;
         }

         if (type.equals("老客户大批量")) {
             System.out.println("打八折！");
             return price * 0.8;
         }

         return price;
     }

     public static void main(String[] args) {
         TestStrategy strategy = new TestStrategy();

         System.out.printf("您该报价：%6.2f", strategy.getPrice("老客户小批量", 998));

         System.out.println("\n---------------------------");

         System.out.printf("您该报价：%6.2f", strategy.getPrice("新客户大批量", 1024));
      }

 }

　　控制台输出：

打八五折！
您该报价：848.30
---------------------------
打九折！
您该报价：921.60

　　注意：实现起来很容易，符号一般开发人员的思路。但是，假如类型很多，算法比较复杂时，整个条件语句的代码就变得很长，难于维护。如果有新增类型，就需要频繁的修改代码。

　　　　   不符合开闭原则！

四、使用策略模式实现报价操作

 /**
  * 策略模式
  * @author CL
  *
  */
 public interface Strategy {

     public double getPrice(double originalCost);

 }

 /**
  * 新客户小批量
  * @author CL
  *
  */
 public class NewCustomerFewStrategy implements Strategy {

     @Override
     public double getPrice(double originalCost) {
         System.out.println("不打折！");
         return originalCost;
     }

 }

 /**
  * 新客户大批量
  * @author CL
  *
  */
 public class NewCustomerManyStrategy implements Strategy {

     @Override
     public double getPrice(double originalCost) {
         System.out.println("打九折！");
         return originalCost * 0.9;
     }

 }

 /**
  * 老客户小批量
  * @author CL
  *
  */
 public class OldCustomerFewStrategy implements Strategy {

     @Override
     public double getPrice(double originalCost) {
         System.out.println("打八五折！");
         return originalCost * 0.85;
     }

 }

 /**
  * 老客户大批量
  * @author CL
  *
  */
 public class OldCustomerManyStrategy implements Strategy {

     @Override
     public double getPrice(double originalCost) {
         System.out.println("打八折！");
         return originalCost * 0.8;
     }

 }

 /**
  * 负责和具体的策略类交互
  * 使策略模式，使具体的算法和直接的客户调用分离，使算法可以独立于客户端进行独立变化。
  * 可以通过构造器注入策略对象的引用，也可以通过set方法注入策略对象的引用。
  * 如果使用spring的依赖注入功能，还可以通过配置文件，动态地注入不同的策略对象，动态的切换不同的算法。
  * @author CL
  *
  */
 public class Context {

     private Strategy strategy;

     //通过构造器注入
     public Context(Strategy strategy) {
         this.strategy = strategy;
     }

     //通过set方法注入
     public void setStrategy(Strategy strategy) {
         this.strategy = strategy;
     }

     public void printPrice(double originalCost) {
         System.out.printf("您该报价：%6.2f", strategy.getPrice(originalCost));
     }

 }

　　测试：

 /**
  * 测试策略模式
  * @author CL
  *
  */
 public class Client {

     public static void main(String[] args) {
         Strategy strategy = new OldCustomerFewStrategy();    //老客户小批量
         Context context = new Context(strategy);

         context.printPrice(998);

         System.out.println("\n---------------------------");

         Strategy strategy2 = new NewCustomerManyStrategy();    //新客户大批量
         Context context2 = new Context(strategy2);

         context2.printPrice(1024);

     }
 }

　　控制台输出：

打八五折！
您该报价：848.30
---------------------------
打九折！
您该报价：921.60

五、策略模式常见开发应用场景

　　（1）市场系统中的报价功能；

　　（2）医保系统中根据不同的人缴纳不同的保险费用；

　　（3）…………