设计模式（二）—策略模式（行为型）

一、定义      

         策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

—抽象策略角色： 策略类，通常由一个接口或者抽象类实现。

—具体策略角色：包装了相关的算法和行为。

—环境角色：持有一个策略类的引用，最终给客户端调用。

二、图分析

 

Context(应用场景):

1、需要使用ConcreteStrategy提供的算法。

2、内部维护一个Strategy的实例。

3、负责动态设置运行时Strategy具体的实现算法。

4、负责跟Strategy之间的交互和数据传递。

Strategy(抽象策略类)：

1、定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，Context使用这个接口调用不同的算法，一般使用接口或抽象类实现。

ConcreteStrategy(具体策略类)：

2、实现了Strategy定义的接口，提供具体的算法实现。

自己的理解：Context通过实现Stragey定义的ContextInterface接口来调用相应的算法

三、代码实现

1、客户端

namespace _2._4策略模式
{
    class Program
    {
        static void Main(string[] args)
        {
            Context context;                                                                                          //声明对象
            context = new Context(new ConcreteStrategyA());                     //实例化对象同时实例化相应的算法类
            context.ContexInterface();                                                                    //通过context调用具体算法

            context = new Context(new ConcreteStrategyB());
            context.ContexInterface();

            context = new Context(new ConcreteStrategyC());
            context.ContexInterface();

            Console.Read();

        }
    }




    //Strtegy类，定义了所有支持的算法的公共接口，抽象算法类
    abstract class Strategy
    { 
        //算法方法
        public abstract void AlgorithmInterface();
    }




    
       //ConcreteStrategy ,封装了具体的算法或行为，继承于Strategy;具体算法A
    class ConcreteStrategyA : Strategy
    { 
    //算法A实现方法
        public override void AlgorithmInterface()
        {
           
                Console.WriteLine ("算法A实现");           
         }
    }




    //具体算法B
    class ConcreteStrategyB : Strategy
    { 
       //算法B实现方法
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法B实现");
        }
    }




    //具体算法C
    class ConcreteStrategyC : Strategy
    { 
        //算法C实现方法
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法C实现");
        }
    }




    //Context,用一个ConcreteStrategy来配置，维护一个队Strategy对象的引用。上下文
    class Context
    {
        Strategy strategy;
        public Context(Strategy strategy)
        {
            this.strategy = strategy;
        }
        //上下文接口
        public void ContexInterface()
        {
            strategy.AlgorithmInterface();
        }
    }
}

四、适用情况（联系生活和以前学习经验）

        机房收费系统中临时用户与固定用户收费方式的差别。

应用场景：

1、多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为。

2、需要在不同情况下使用不同的策略(算法)，或者策略还可能在未来用其它方式来实现。

3、对客户隐藏具体策略(算法)的实现细节，彼此完全独立。

五、优缺点  

优点：

1、提供了一种替代继承的方法，而且既保持了继承的优点(代码重用)还比继承更灵活(算法独立，可以任意扩展)。

2、避免程序中使用多重条件转移语句，使系统更灵活，并易于扩展。

3、高内聚、低偶合。

缺点：

1、因为每个具体策略类都会产生一个新类，所以会增加系统需要维护的类的数量。

解决方案：工厂方法

六、简单工厂与策略模式的区别

 1、 简单工厂模式中我们只需要传递相应的条件就能得到想要的一个对象，然后通过这个对象实现算法的操作。

       策略模式使用时必须首先创建一个想使用的类对象，然后将该对象作为参数传递进去，通过该对象调用不同的算法。

2、简单工厂中实现了通过条件选取一个类去实例化对象，策略模式则将选取相应对象的共做交给模式的使用者，它本身不去做选取工作。

3、Factory是直接创建具体的对象并用该对象去执行相应的操作，而Context将这个操作给了Context类，没有创建具体的对象，实现代码的进一步封装，客户端代码不需要知道具体的实现过程。