大话设计模式1-简单工厂模式

1.工厂模式.

　　实例:计算器

　　创建方法:

首先是运算类,它有两个Number属性,用于计算计算器的前后数;

然后有一个虚方法GetResult,用于得到结果;

1 运算类

2 {

3     两个Number属性{get;set;} //主要用于计算前后数,NumA,NumB

4     虚方法GetResult//用于得到结果

5 }

把加减乘除都写成子运算类的子类,继承它,重写了GetResult()方法,

 1 运算类子类:运算类//运算类子类  继承  运算类

 2  {

 3     //重写GetRsult方法

 4     运算类子类1//这里 如果不写  就为 private

 5     {

 6         public overrive 运算方法{};

 7         //切记这里是public,上面一行不要加public,不加就是默认private.  加了之后会报错.访问级别导致不知道要访问overrive之前的还是现在的方法

 8     }

 9      运算类子类2

10     {

11         public overrive 运算方法{};

12     }

13     运算类子类3

14     {

15         public overrive 运算方法{};

16     }

17 }

 

这样如果要修改任何一个算法，都不需要提供其它算法的代码了.

让计算器指导我是希望用哪一种算法:

 1 运算类工厂

 2 {

 3     public static 运算类 CreateFunction(string 传入参数)//切记前面的static不能忘了,返回值类型为  运算类

 4     {

 5         运算类 my=null;

 6         switch(传入参数)

 7         {

 8            case "+":

 9                my=new 运算子类1();

10                break;

11            case "-":

12                my=new 运算子类2();

13                break;

14            case "*":

15                my=new 运算子类3();

16                break;

17         }

18            return my;//返回  运算类  类型

19     }

20 

21 }

在Program中调用,只要输入运算符号,用工厂实例化合适的对象,通过多台,返回父类的方式实现计算器的结果.

1 //Program.cs

2 

3 运算类 mynew;

4 mynew=运算类工厂.CreateFunction("传入的值");

5 mynew.NumA=数字A;

6 mynew.Numb=数字B;

7 Console.WriteLine(mynew.GetResult().toString());

 这样 需要增加各种复杂运算，比如平方根，立方根，自然对数，正弦余弦等，只要增加相应的运算子类就可以了.

 完整代码:

 1 /**//// <summary>

 2     /// 运算类

 3     /// </summary>

 4     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             double result = 0; 

34             return result;

35         }

36 

37        

38     }

运算类View Code

 

 1   /**//// <summary>

 2     /// 加法类

 3     /// </summary>

 4     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     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     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     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     }

运算子类 View Code

 

 1   /**//// <summary>

 2     /// 运算类工厂

 3     /// </summary>

 4     class OperationFactory

 5     {

 6         public static Operation createOperate(string operate)

 7         {

 8             Operation oper = null;

 9             switch (operate)

10             {

11                 case "+":

12                     {

13                         oper = new OperationAdd();

14                         break;

15                     }

16                 case "-":

17                     {

18                         oper = new OperationSub();

19                         break;

20                     }

21                 case "*":

22                     {

23                         oper = new OperationMul();

24                         break;

25                     }

26                 case "/":

27                     {

28                         oper = new OperationDiv();

29                         break;

30                     }

31              }

32 

33             return oper;

34         }

35     }

运算类工厂 View Code

 

1 Operation oper;

2 oper = OperationFactory.createOperate("+");

3 oper.NumberA = 1;

4 oper.NumberB = 2;

5 double result = oper.GetResult();

实现 View Code

 

工厂模式和策略模式的区别:

      策略，从字面就好理解，意思是一种决策，所以通常它都适用于一些商务逻辑或算法等类的选择上，因此只要是一些涉及到商务逻辑（都是继承同一个抽象类的子类）的选择时，都可以考虑用策略模式。从这个角度讲，策略模式在面向对象编程中的应用可说是无处不在，它是最最常见的模式。 
      而简单工厂模式，主要解决的是类的实例化问题，把实例化的决策从客户端转移到工厂类当中，让客户端只是输入一个比如“字符串”这样的标识就可以通过简单工厂生成一个相应的类实例。这个模式是解决类的创建问题。
　　它们两者并不矛盾，因此不要有非此即彼的想法。事实上把它们结合使用会更有意义。

 

 参考:大话设计模式