简单工厂(计算器)

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
5. namespace Operation
6. {
7.     /// <summary>
8.     /// 运算类
9.     /// </summary>
10.     public class Operation
11.     {
12.         private double _numberA = 0;
13.         private double _numberB = 0;
14.         
15.         /// <summary>
16.         /// 数字A
17.         /// </summary>
18.         public double NumberA
19.         {
20.             get
21.             {
22.                 return _numberA;
23.             }
24.             set
25.             {
26.                 _numberA = value;
27.             }
28.         }
30.         /// <summary>
31.         /// 数字B
32.         /// </summary>
33.         public double NumberB
34.         {
35.             get
36.             {
37.                 return _numberB;
38.             }
39.             set
40.             {
41.                 _numberB = value;
42.             }
43.         }
45.         /// <summary>
46.         /// 得到运算结果
47.         /// </summary>
48.         /// <returns></returns>
49.         public virtual double getResult()
50.         {
51.             double result = 0; 
52.             return result;
53.         }
55.        
56.     }
58.     /// <summary>
59.     /// 加法类
60.     /// </summary>
61.     class OperationAdd : Operation
62.     {
63.         public override double getResult()
64.         {
65.             double result = 0; 
66.             result = NumberA + NumberB;
67.             return result;
68.         }
69.     }
71.     /// <summary>
72.     /// 减法类
73.     /// </summary>
74.     class OperationSub : Operation
75.     {
76.        public override double getResult()
77.         {
78.             double result = 0;
79.             result = NumberA - NumberB;
80.             return result;
81.         }
82.     }
84.     /// <summary>
85.     /// 乘法类
86.     /// </summary>
87.     class OperationMul : Operation
88.     {
89.         public override double getResult()
90.         {
91.             double result = 0;
92.             result = NumberA * NumberB;
93.             return result;
94.         }
95.     }
97.     /// <summary>
98.     /// 除法类
99.     /// </summary>
100.     class OperationDiv : Operation
101.     {
102.         public override double getResult()
103.         {
104.             double result = 0;
105.             if (NumberB==0)
106.                 throw new Exception("除数不能为0。");
107.             result = NumberA / NumberB;
108.             return result;
109.         }
110.     }
112.     /// <summary>
113.     /// 平方类
114.     /// </summary>
115.     class OperationSqr : Operation
116.     {
117.         public override double getResult()
118.         {
119.             double result = 0;
120.             result = NumberB * NumberB;
121.             return result;
122.         }
123.     }
125.     /// <summary>
126.     /// 平方根类
127.     /// </summary>
128.     class OperationSqrt : Operation
129.     {
130.         public override double getResult()
131.         {
132.             double result = 0;
133.             if (NumberB < 0)
134.                 throw new Exception("负数不能开平方根。");
135.             result = Math.Sqrt(NumberB);
136.             return result;
137.         }
138.     }
140.     /// <summary>
141.     /// 相反数类
142.     /// </summary>
143.     class OperationReverse : Operation
144.     {
145.         public override double getResult()
146.         {
147.             double result = 0;
148.             result = -NumberB;
149.             return result;
150.         }
151.     }
153.     /// <summary>
154.     /// 运算类工厂
155.     /// </summary>
156.     class OperationFactory
157.     {
158.         public static Operation createOperate(string operate)
159.         {
160.             Operation oper = null;
161.             switch (operate)
162.             {
163.                 case "+":
164.                     {
165.                         oper = new OperationAdd();
166.                         break;
167.                     }
168.                 case "-":
169.                     {
170.                         oper = new OperationSub();
171.                         break;
172.                     }
173.                 case "*":
174.                     {
175.                         oper = new OperationMul();
176.                         break;
177.                     }
178.                 case "/":
179.                     {
180.                         oper = new OperationDiv();
181.                         break;
182.                     }
183.                 case "sqr":
184.                     {
185.                         oper = new OperationSqr();
186.                         break;
187.                     }
188.                 case "sqrt":
189.                     {
190.                         oper = new OperationSqrt();
191.                         break;
192.                     }
193.                 case "+/-":
194.                     {
195.                         oper = new OperationReverse();
196.                         break;
197.                     }
198.             }
200.             return oper;
201.         }
202.     }
204. }

UML图：