Chinaunix首页 | 论坛 | 博客
  • 博客访问: 448051
  • 博文数量: 80
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 1916
  • 用 户 组: 普通用户
  • 注册时间: 2013-07-11 22:01
个人简介

从事实时计算多年,熟悉jstorm/spark/flink/kafka/rocketMq, 热衷于开源,希望在这里和前辈们一起学习与分享,得到长足的进步!邮箱:hustfxj@gmail.com 我的githup地址是:https://github.com/hustfxj。欢迎和大家一起交流探讨问题。

文章分类

全部博文(80)

文章存档

2017年(11)

2015年(3)

2014年(33)

2013年(33)

分类: C#/.net

2014-06-14 21:00:41

最近一直在抽时间研究设计模式,之前对设计模式也有一定的了解,但是都没有平心静气的去研究过,只是了解了一些皮毛,最近打算再深入研究一下,重新打开了设计模式的数据,对之前的疑问一个个的刨根问底,今天看了简单工厂模式和策略模式看的人有点小晕,两个的大概思路没有怎么变,都是通过多态去减少代码的耦合度,怎么看两个都是如出一辙,最后终于找到了两个的本质区别,在此和大家分享下:

先上代码:

点击(此处)折叠或打开

  1. //抽象类
  2. abstract class AbsClass
  3. {
  4.     //抽象方法:提供一些列的算法操作
  5.     public abstract void acceptCash(string org);
  6. }

  7. //继承自抽象类
  8. class A:AbsClass
  9. {
  10.     //具体方法:提供一些列的算法操作
  11.     public override double acceptCash(string org)



  12.          Console.WriterLine("A类方法");

  13.   }
  14. }

  15.  

  16. //继承自抽象类
  17. class B:AbsClass
  18. {
  19.     //具体方法:提供一些列的算法操作
  20.     public override double acceptCash(string org)



  21.          Console.WriterLine("B类方法");

  22.   }
  23. }

  24. ... .... ....

  25. 简单工厂类

  26. //现金收取工厂
  27. class CashFactory
  28. {
  29.     //根据条件返回相应的对象
  30.     public static AbsClass createCashAccept(string type)
  31.     {
  32.         AbsClass cs = null;
  33.         switch (type)
  34.         {
  35.             case "A":
  36.                 cs = new Al();
  37.                 break;
  38.             case "B":
  39.                 cs = new B();
  40.                 break;
  41.             case "...":
  42.                 ........ ....
  43.                 break;
  44.         }
  45.         return cs;
  46.     }
  47. }

  48.  

  49. 客户端调用:

  50. /利用简单工厂模式根据下拉选择框,生成相应的对象
  51. AbsClass csuper = CashFactory.createCashAccept("A");

  52.  

  53. 策略模式:

  54.  前面的类没有任何变化,只是把Factory变成了CaseContext策略类

  55. //策略Context
  56. class CashContext
  57. {
  58.     //声明一个现金收费父类对象
  59.     private AbsClass cs;

  60.     //设置策略行为,参数为具体的现金收费子类(正常,打折或返利)
  61.     public CashContext(AbsClass csuper)
  62.     {
  63.         this.cs = csuper;
  64.     }

  65.     //得到现金促销计算结果(利用了多态机制,不同的策略行为导致不同的结果)
  66.     public double GetResult(double money)
  67.     {
  68.         return cs.acceptCash(money);
  69.     }
  70. }

  71.  

  72. 客户端调用:

  73. AbsClass cc = null;
  74.    switch (cbxType.SelectedItem.ToString())
  75.             {
  76.                 case "A":
  77.                     cc = new CashContext(new A());
  78.                     break;
  79.                 case "B":
  80.                     cc = new CashContext(new B());
  81.                     break;
  82.                 case "...":
  83.                     ... ....
  84.                     break;
  85.             }

最后概括总结一下:

策略模式和简单工厂模式看起来非常相似,都是通过多态来实现不同子类的选取,这种思想应该是从程序的整体来看得出的。如果从使用这两种模式的角度来看的话,我们会发现在中我们只需要传递相应的条件就能得到想要的一个对象,然后通过这个对象实现算法的操作。而,使用时必须首先创建一个想使用的类对象,然后将该对象最为参数传递进去,通过该对象调用不同的算法。在简单工厂模式中实现了通过条件选取一个类去实例化对象,策略模式则将选取相应对象的工作交给模式的使用者,它本身不去做选取工作。

结合上面的代码和下面的释义不难看出,其实两个的差别很微妙,Factory是直接创建具体的对象并用该对象去执行相应的动作,而Context将这个操作给了Context类,没有创建具体的对象,实现的代码的进一步封装,客户端代码并不需要知道具体的实现过程。

阅读(1907) | 评论(0) | 转发(0) |
0

上一篇:异步和多线程区别

下一篇:storm简介

给主人留下些什么吧!~~