设计模式系列-策略模式

      今天下班回家，吃完晚饭后在网上闲逛，看了看电视剧《男人帮》的经典台词，感觉很经典，虽然这个电视剧我早已经在上个月就看完了，但是看了看里面的经典开场白和台词，还是不由自主的伸出大拇指，赞啊！

创新互联长期为超过千家客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为资源企业提供专业的成都网站设计、成都网站建设，资源网站改版等技术服务。拥有10多年丰富建站经验和众多成功案例,为您定制开发。

       列举部分台词如下：

      （1）自从我们睁开眼睛看这个世界的第一天起， 我们看到的就只有两种人，男人和女人。 他们分属于两大不同的阵营，为了彻底收服对方，大家互相往死里掐。
      （2）根据一个遥远的传说，说有一种东西叫爱情，可以彻底终结这场战争。 于是大家纷纷的赶紧去寻找，赶紧去幻想， 找到头破血流才发现，原来这个感情也是另一些人在书房里炮制出来的。 于是大家更加绝望，更加痛苦，更加互相的往死里掐。 

        1、场景案例
       尤其是上面这几句，让我想起了我一同事（这里用“某某哥”代替）和他女朋友的故事（这里用“某某嫂”代替），一次活动中，某某哥认识了某某嫂，那个一见钟情呀，简直是看不见某某嫂就吃不下饭、写不下代码呀，在追求中也没少费工夫。比如：送小礼物，请客吃饭，搞浪漫等等，我们就把这几个阶段分别用代码模拟一下把！

           ①第一阶段赠送小礼物代码如下：

//第一阶段 送小礼物 
    public static void SendGift()  
    {  
        Console.WriteLine("送给女方精美小礼物！");  
    }  
 
    static void Main(string[] args)  
    {  
        //第一阶段  
        SendGift();  
    } 

           ② 此时、通过送精美小礼物女方已经愿意与男方接触，这时就可以一起吃饭了，代码如下：

//第一阶段 送小礼物 
 public static void SendGift()  
 {  
     Console.WriteLine("送给女方精美小礼物！");  
 }  
 
 //添加 第二阶段 请客吃饭 
 public static void Eat()  
 {  
     Console.WriteLine("请女生吃牛排！");  
 }  
 
 static void Main(string[] args)  
 {  
     //第一阶段  
     //SendGift(); //此时第一阶段已经不需要了所以注销掉进入第二阶段 
 
     //第二阶段 
     Eat();  
 } 

         ③ 经过之前阶段的接触，两人已经在一起了，在一起就免不了在热恋中经历浪漫情节，第三阶段：制造浪漫、代码如下：

//第一阶段 送小礼物 
      public static void SendGift()  
      {  
          Console.WriteLine("送给女方精美小礼物！");  
      }  
 
      //添加 第二阶段 请客吃饭 
      public static void Eat()  
      {  
          Console.WriteLine("请女生吃牛排！");  
      }  
 
      //添加 第三阶段 浪漫：烛光晚餐等待女友 
      public static void Romantic()  
      {  
          Console.WriteLine("精心制作了红酒、晚餐与蜡烛，等待女友回家！");  
      }  
 
      static void Main(string[] args)  
      {  
          //第一阶段  
          //SendGift(); //此时第一阶段已经不需要了所以注销掉进入第二阶段 
 
          //第二阶段 
          //Eat(); //此时第二阶段也已经经过，所以注销掉、进入第三阶段 
 
          //第三阶段 
          Romantic();  
      }  

//第一阶段 送小礼物 
        public static void SendGift()  
        {  
            Console.WriteLine("送给女方精美小礼物！");  
        }  
 
        //添加 第二阶段 请客吃饭 
        public static void Eat()  
        {  
            Console.WriteLine("请女生吃牛排！");  
        }  
 
        //添加 第三阶段 浪漫：烛光晚餐等待女友 
        public static void Romantic()  
        {  
            Console.WriteLine("精心制作了红酒、晚餐与蜡烛，等待女友回家！");  
        }  
 
        static void Main(string[] args)  
        {  
            Console.Write("现在是第几阶段？：");  
            string level = Console.ReadLine(); //代表当前是哪个阶段 
            switch (level)  
            {  
                case "one"://第一阶段  
                    SendGift();  
                    break;  
                case "two"://第二阶段 
                    Eat();  
                    break;  
                case "three": //第三阶段 
                    Romantic();  
                    break;  
                default:  
                    Console.WriteLine("没这个打算凑什么热闹？");  
                    break;  
            }  
        }  

         那么如果这时两人已经到了谈婚论嫁的时候，该怎么办呢？也就是要在新加入一个阶段叫做结婚呢？

          2、引入策略模式

         普通的办法还是要去新增方法，在修改调用代码！那我们有没有办法呢？别着急，先看看策略模式、定义如下：“它定义了算法家族，分别封装起来，让他们之间可以互相替换，次模式让算法的变化，不会影响到使用算法的客户”。

          策略模式类图如下：

         那么使用策略模式改装，我们上面场景的类图如下：

          模拟出了类型那么我们写代码当然也就不难啦。

          ① 首先呢，我们需要抽象出来追女孩策略，这个策略里面有一个公共的接口就是去做（也就是行动的意思），例如：送礼物、吃饭、浪漫，都是需要人去做去行动的。

//追女孩策略抽象类 
 public abstract class PursueaGirlStrategy  
 {  
     //追女孩策略中都有一个统一的接口，就是行动。 
     public abstract void Justdoit();  
 }  

//第一阶段 送小礼物 
   public class SendGiftStrategy : PursueaGirlStrategy  
   {  
       public override void Justdoit()  
       {  
           Console.WriteLine("送给女方精美小礼物！");  
       }  
   }  
 
   //第二阶段 请客吃饭 
   public class EatStrategy : PursueaGirlStrategy  
   {  
       public override void Justdoit()  
       {  
           Console.WriteLine("请女生吃牛排！");  
       }  
   }  
 
   //第三阶段 浪漫：烛光晚餐等待女友 
   public class RomanticStrategy : PursueaGirlStrategy  
   {  
       public override void Justdoit()  
       {  
           Console.WriteLine("精心制作了红酒、晚餐与蜡烛，等待女友回家！");  
       }  
   }  

//策略的宿主 承载当前需要执行的策略 
   public class PursueaGirlContext  
   {  
       SendGiftStrategy staregy;  
       public PursueaGirlContext(SendGiftStrategy strategy)  
       {  
           this.staregy = strategy;  
       }  
 
       //调用策略的公共接口方法 
       public void ContextJustdoit()  
       {  
           if (this.staregy != null)  
           {  
               this.staregy.Justdoit();  
           }  
       }  
 
   }  
      main方法将来调用如下：  
 
 static void Main(string[] args)  
       {  
           //定义追女孩策略上下文对象 
           PursueaGirlContext context = null;  
           Console.Write("现在是第几阶段？：");  
           string level = Console.ReadLine(); //代表当前是哪个阶段 
           switch (level)  
           {  
               case "one"://第一阶段  
                   context = new PursueaGirlContext(new SendGiftStrategy());  
                   break;  
               case "two"://第二阶段 
                   context = new PursueaGirlContext(new EatStrategy());  
                   break;  
               case "three": //第三阶段 
                   context = new PursueaGirlContext(new RomanticStrategy());  
                   break;  
               default:  
                   Console.WriteLine("没这个打算凑什么热闹？");  
                   break;  
           }  
 
           //统一的策略调用模式 
           context.ContextJustdoit();  
       }  

          3、策略模式与工厂模式的区别

          概念上理解：

                     ① 策略模式：是告诉上下文，我需要去做什么，至于使用怎么实现，需要上下文去使用当前对应的策略去实现。例如：项目经理（客户端）说：“我要实现即时消息功能”，那么我们程序员（上下文）就需要去寻找对应的策略（开发即时消息模块的策略）去实现。

                     ②工厂模式：是告诉工厂，此时我需要什么部件你去给我制造，例如：开发及时消息模块，我需要JS的弹出框，我就会告诉UI组（工厂），给我做一个JS弹出框，要求模仿EXT的。

          4、策略与工厂谈恋爱

           那么了解了他们之间的区别后，我们再来看上面策略模式实现的一个问题，例如：需要加入结婚策略时，还是需要增加结婚策略类，并且修改客户端（MAIN方法）中的调用代码。那么我们把提供使用策略的代码放到工厂中呢？这样我们以后就只需要增加新策略修改工厂就行啦！客户端就不用修改了。

           ①工厂代码代码如下：

//提供策略的工厂 
    public class FactoryStrategy  
    {  
        //根据客户端参数创建策略 
        public static PursueaGirlContext GetStrategy(string level)  
        {  
            //定义追女孩策略上下文对象 
            PursueaGirlContext context = null;  
            switch (level)  
            {  
                case "one"://第一阶段  礼物 
                    context = new PursueaGirlContext(new SendGiftStrategy());  
                    break;  
                case "two"://第二阶段 吃饭 
                    context = new PursueaGirlContext(new EatStrategy());  
                    break;  
                case "three": //第三阶段 浪漫 
                    context = new PursueaGirlContext(new RomanticStrategy());  
                    break;  
                case "four"://第四阶段 结婚 
                    context = new PursueaGirlContext(new MarriedStrategy());  
                    break;  
                default:  
                    context = null;  
                    break;  
            }  
            return context;  
        }  
    }  

static void Main(string[] args)  
       {  
            
           Console.Write("现在是第几阶段？：");  
           string level = Console.ReadLine(); //代表当前是哪个阶段 
 
           //定义追女孩策略上下文对象 
           PursueaGirlContext context = FactoryStrategy.GetStrategy(level);  
 
           //统一的策略调用模式 
           context.ContextJustdoit();  
       }  

//追女孩策略抽象类 
    public abstract class PursueaGirlStrategy  
    {  
        //追女孩策略中都有一个统一的接口，就是行动。 
        public abstract void Justdoit();  
    }  
 
    //第一阶段 送小礼物 
    public class SendGiftStrategy : PursueaGirlStrategy  
    {  
        public override void Justdoit()  
        {  
            Console.WriteLine("送给女方精美小礼物！");  
        }  
    }  
 
    //第二阶段 请客吃饭 
    public class EatStrategy : PursueaGirlStrategy  
    {  
        public override void Justdoit()  
        {  
            Console.WriteLine("请女生吃牛排！");  
        }  
    }  
 
    //第三阶段 浪漫：烛光晚餐等待女友 
    public class RomanticStrategy : PursueaGirlStrategy  
    {  
        public override void Justdoit()  
        {  
            Console.WriteLine("精心制作了红酒、晚餐与蜡烛，等待女友回家！");  
        }  
    }  
 
    //添加第四阶段 结婚 
    public class MarriedStrategy : PursueaGirlStrategy  
    {  
        public override void Justdoit()  
        {  
            Console.WriteLine("两人民政局领证！");  
        }  
    }  
 
    //提供策略的工厂 
    public class FactoryStrategy  
    {  
        //根据客户端参数创建策略 
        public static PursueaGirlContext GetStrategy(string level)  
        {  
            //定义追女孩策略上下文对象 
            PursueaGirlContext context = null;  
            switch (level)  
            {  
                case "one"://第一阶段  礼物 
                    context = new PursueaGirlContext(new SendGiftStrategy());  
                    break;  
                case "two"://第二阶段 吃饭 
                    context = new PursueaGirlContext(new EatStrategy());  
                    break;  
                case "three": //第三阶段 浪漫 
                    context = new PursueaGirlContext(new RomanticStrategy());  
                    break;  
                case "four"://第四阶段 结婚 
                    context = new PursueaGirlContext(new MarriedStrategy());  
                    break;  
                default:  
                    context = null;  
                    break;  
            }  
            return context;  
        }  
    }  
 
    //策略的宿主 承载当前需要执行的策略 
    public class PursueaGirlContext  
    {  
        PursueaGirlStrategy staregy;  
        public PursueaGirlContext(PursueaGirlStrategy strategy)  
        {  
            this.staregy = strategy;  
        }  
 
        //调用策略的公共接口方法 
        public void ContextJustdoit()  
        {  
            if (this.staregy != null)  
            {  
                this.staregy.Justdoit();  
            }  
        }  
 
    }  
    static void Main(string[] args)  
        {  
             
            Console.Write("现在是第几阶段？：");  
            string level = Console.ReadLine(); //代表当前是哪个阶段 
 
            //定义追女孩策略上下文对象 
            PursueaGirlContext context = FactoryStrategy.GetStrategy(level);  
 
            //统一的策略调用模式 
            context.ContextJustdoit();  
        }