设计模式------策略模式

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

父类Strategy定义所有算法的公共接口，比如说不管打折、原价、或者满减模式，都会得到一个价格的接口getResult()

伪代码示例：

// 抽象算法父类
abstract class father
{
    // 算法方法
    public void fun();
}
// 算法1
class son1 extends father
{
    public void fun()
    {
        // 算法1
    }
}
// 算法2
class son2 extends father
{
    public void fun()
    {
        // 算法2
    }
}
// 算法3
class son3 extends father
{
    public void fun()
    {
        // 算法3
    }
}
// 使用一个上下文contex类来维护对父类对象的引用
class context
{
    father fa;
    public context(father fatmp)
    {
        this.fa = fatmp;
    }
    // 上下文接口
    public void Contextinterface()
    {
        fa.fun();
    }
}
// 实现
public static void main(String args[])
{
    context co;
    // 算法1调用
    co = new context(new son1);
    co.Contextinterface();

    // 算法2调用
    co = new context(new son2);
    co.Contextinterface();

    // 算法3调用
    co = new context(new son3);
    co.Contextinterface();
}
// 所以，策略模式就是通过Contextinterface函数使得具体算法和客户进行了隔离。但是这里依然有所不足，客户接触了太多的算法类，比如son1，son2，son3等，要克服这个问题就需要使用策略与简单工厂结合的方法。

策略与简单工厂结合：

// 修改引用类context
class context
{
    father fa=null;
    public context(String type)
    {
        switch(type)
        {
            case 类型1：
                son1 s1 = new son1();
                fa = s1;
                break;
            case 类型2：
                son2 s2 = new son2();
                fa = s2;
                break;
            case 类型3：
                son3 s3 = new son3();
                fa = s3;
                break;
        }
    }
    public void fun()
    {
        ...
    }
}
// 直接将算法类包含进context中，客户端不再接触具体算法类，只需要处理context即可。

总结：

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

优点：

1. 策略模式的父类层次为引用类context定义了一系列可重用的算法或行为，继承有助于析取出这些算法中公共功能。比如商品贩卖各种形式的GetResult()接口。

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

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

4. 在以上的策略模式和简单工厂模式结合中，将客户端的判断压力给了context，在context中使用了switch，简化了客户端的职责。