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）…………