观《大话设计模式》之——简单工厂模式

　　面向对象有啥好处？为啥要用面向对象来进行软件开发？没看之前，了解的不过，理解也不深刻，看了《大话设计模式》第一章，印象也深刻了，理解也加深了。当我学了面向对象的分析设计编程思想，开始考虑通过封装、继承、多态把程序的耦合度降低。使程序更加的灵活，容易修改，并且易于复用。

　　那么何谓是简单工厂模式呢，因为在我们日常编程中，经常出现一种情况就是每当“new”一个对象之后，这个对象就依赖于某个类。如果在后期的维护过程中由于某些原因需要修改一下这个类，则唯一的做法就是打开源代码，进行修改，修改所有与这个对象有关的操作。这对我们是非常不利的。问题出来了：对象不能应对“具体实例化类型”的变化。那么简单工厂模式就是出来了，它的意图就是：专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类或接口。或者是提供一个类，由它负责根据一定的条件创建某一具体类的实例。

　　下面就写写我看完《大话设计模式》第一章之后的心得吧！就拿书中的例子来讲：请实现一个简单的计算器控制台的程序。

1、业务的封装

　　运算类：

 1     /// <summary>

 2     /// 运算操作类

 3     /// </summary>

 4     public class Operation

 5     {

 6         private double _numberA = 0;

 7         private double _numberB = 0;

 8 

 9         /// <summary>

10         /// 输入值A

11         /// </summary>

12         public double NumberA

13         { 

14             get {    return _numberA;    }

15             set {    _numberA = value;    }

16         }

17 

18         /// <summary>

19         /// 输入值B

20         /// </summary>

21         public double NumberB

22         {

23             get { return _numberB; }

24             set { _numberB = value; }

25         }

26 

27         /// <summary>

28         /// 运算的虚方法

29         /// </summary>

30         /// <returns></returns>

31         public virtual double GetResult()

32         {

33             return 0;

34         }

35     }

　　加减乘除类，继承与运算类

 1     /// <summary>

 2     /// 加法类

 3     /// </summary>

 4     public class OperationAdd : Operation

 5     {

 6         public override double GetResult()

 7         {

 8             double result = 0;

 9             result = NumberA + NumberB;

10             return result;

11         }

12     }

13 

14     /// <summary>

15     /// 减法类

16     /// </summary>

17     public class OperationSub : Operation

18     {

19         public override double GetResult()

20         {

21             double result = 0;

22             result = NumberA - NumberB;

23             return result;

24         }

25     }

26 

27     /// <summary>

28     /// 乘法类

29     /// </summary>

30     public class OperationMul : Operation

31     {

32         public override double GetResult()

33         {

34             double result = 0;

35             result = NumberA * NumberB;

36             return result;

37         }

38     }

39 

40     /// <summary>

41     /// 除法类

42     /// </summary>

43     public class OperationDiv : Operation

44     {

45         public override double GetResult()

46         {

47             double result = 0;

48             if(NumberB==0)

49                 throw new Exception("除数不能为0。");

50             result = NumberA / NumberB;

51             return result;

52         }

53     }

　　工厂类：

 1     /// <summary>

 2     /// 运算符的简单工厂类

 3     /// </summary>

 4     public class SimpleFactory

 5     {

 6         public  static Operation CreateOperate(string operate)

 7         {

 8             Operation oper = null;

 9             switch (operate)

10             {

11                 //实例化加法类

12                 case "+":

13                     oper=new OperationAdd();

14                     break;

15                 //实例化减法类

16                 case "-":

17                     oper = new OperationSub();

18                     break;

19                 //实例化乘法类

20                 case "*":

21                     oper=new OperationMul();

22                     break;

23                 //实例化除法类

24                 case "/":

25                     oper=new OperationDiv();

26                     break;

27             }

28 

29             return oper;

30         }

31     }

　　最后就是客户端调用的方法了：

 1         static void Main(string[] args)

 2         {

 3             double result;

 4             Operation operAdd = SimpleFactory.CreateOperate("+");

 5             operAdd.NumberA = 1;

 6             operAdd.NumberB = 2;

 7             result = operAdd.GetResult();

 8             Console.WriteLine("加法运算的结果值为:{0}", result);

 9             Operation operSub = SimpleFactory.CreateOperate("-");

10             operSub.NumberA = 4;

11             operSub.NumberB = 2;

12             result = operSub.GetResult();

13             Console.WriteLine("减法运算的结果值为:{0}", result);

14             Console.ReadKey();

15         }

2.运算结果

　　

3.简单工厂的优势和劣势

优势：

• 简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。通过它，外界可以从直接创建具体产品对  象的尴尬局面中摆脱出来。
• 外界与具体类隔离开来，偶合性低。
• 明确区分了各自的职责和权力，有利于整个软件体系结构的优化。　

劣势：

• 工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则 
• 虽然简单工厂模式能够适应一定的变化，但是它所能解决的问题是远远有限的。它所能创建的类只能是事先教考虑到的，如果需要添加新的类，则就需要改变工厂类了。

应用情况：

• 工厂类负责创建的对象比较少
• 客户只知道传入了工厂类的参数，对于始何创建对象（逻辑）不关心 

　　最后限于本人水平有限，有不足之处请多多拍砖！

参考引用：

　　1.程杰著作的 《大话设计模式》

　　2.博客园里的某篇文章—《.NET设计模式(1): 简单工厂模式》