设计模式--简单工程模式

对于大话设计模式这本书，之前有看过，但是一直没有仔细的看，也没有记笔记，跟没有在工作中用到过设计模式，除了简单工厂，工厂模式外。下面就根据再次看大话设计模式整理出来实例做分析，主要是书中的例子。如有不到之处还请各位大神指出。

简单工厂模式和继承是分不开的我们还是以计算器为例：

1.运算类

是一个基类，里面包含需要参与计算的两个参数，和一个获取计算结果的方法

 1  /// <summary>
 2     /// 运算类    
 3     /// </summary>
 4     public class Operation
 5     {
 6         public double NumberA { get; set; }//第一个数
 7         public double NumberB { get; set; }//第二个数
 8 
 9         /// <summary>
10         /// 返回计算结果
11         /// </summary>
12         /// <returns></returns>
13         public virtual double GetResult() 
14         {
15             double result = 0;
16             return result;
17         }
18     }

2.实现类

实现基类的方法，并各自实现自己的计算

/// <summary>
    /// 加法类   
    /// </summary>
    public class OperationAdd : Operation//继承运算类
    {
        public override double GetResult()
        {
            double result = NumberA + NumberB;
            return result;
        }
    }

 /// <summary>
    /// 减法类
    /// </summary>
    public class OperationSub:Operation//继承运算类
    {
        public override double GetResult()
        {
            double result = NumberA - NumberB;
            return result;
        }
    }

 1     /// <summary>
 2     /// 乘法类
 3     /// </summary>
 4     public class OperationMul : Operation//继承运算类
 5     {
 6         public override double GetResult()
 7         {
 8             double result = NumberA * NumberB;
 9             return result;
10         }
11     }

 1     /// <summary>
 2     /// 除法类
 3     /// </summary>
 4     public class OperationDiv:Operation //继承运算类
 5     {
 6         public override double GetResult()
 7         {
 8             double result = 0;
 9             if (NumberB == 0)
10                 throw new Exception("除数不能为0");
11             result = NumberA / NumberB;
12             return result;
13         }
14     }

以上为各自的实现类，都调用了父类的两个参数，重写父类方法并有各自的实现，那么我们如何来动态的创建实例呢，这块就用到了我们的工厂，下面看看工厂代码：

 1      /// <summary>
 2     /// 运算工厂
 3     /// </summary>
 4     public class OperationFactory
 5     {
 6         /// <summary>
 7         /// 根据参数创建需要的实例
 8         /// </summary>
 9         /// <param name="operationType">需要创建实例 的类型</param>
10         /// <returns>返回创建好的实例</returns>
11         public static Operation CreateOperation(string operationType) 
12         {
13             Operation operat = null;
14             switch (operationType)
15             {
16                 case "+":
17                     operat = new OperationAdd();
18                     break;
19                 case "-":
20                     operat = new OperationSub();
21                     break;
22                 case "*":
23                     operat = new OperationMul();
24                     break;
25                 case "/":
26                     operat = new OperationDiv();
27                     break;
28             }
29 
30             return operat;
31         }
32     }

看以上为工厂方法，需要调用的时候只需要传递不同的操作计算类型即可获得实例：如以下调用

　　　　public static void Main(string[] args)
        {
            //创建加法计算实例 看括号可传递一个运算类型就可以  不同的实例不    用创建多个可根据参数动态创建
            Operation operat = OperationFactory.CreateOperation("+");//操作符可根据需求动态传递
            operat.NumberA = 13;//第一个参数赋值
            operat.NumberB = 15;//第二个参数赋值
            Console.WriteLine("{0}加{1}等于：{2}", operat.NumberA, operat.NumberB, operat.GetResult());
        }

以上为加法计算其他计算只需修改工厂创建参数即可

运算结果：

总结：简单工厂模式即把对象的创建放到一个工厂类中，通过参数来创建不同的对象。

便于以后的调整对给系统带来更大的可扩展性和尽量少的代码修改。给你系统带来更大的可扩展性和尽量少的修改量。