设计模式（1）---简单工厂模式

　　引言：

　　从接触编码到如今有一段时间了，老是在为一些基础语法、技能而不断学习，学着学着感受有些茫然。在上一篇曾经说过一大牛的教诲：“c语言、java语言、C#语言这些都是一些基本的工具，而它们其中的语法、技能都是一些很简单的基础知识，刚接触编码时确定会有不少的知识、技能你不懂，但你只要碰到而且学习确定可以熟练使用。因此语言、技能都不重要，重要的是脱离语言工具的思想，编程的思想。设计模式是思想的体现，多多学习确定没错”。这以后一直在看设计模式方面的书，但“纸上得来终觉浅，绝知此事要躬行”，因而想把看的书、评论、博客等一些东西总结到一块摘写出来，加深印象同时方便学习。如今开始第一篇：简单工厂模式。

　　定义：

　　定义一个类专门负责建立其余类的实例，具体建立什么实例由传入的参数而决定，而且这些类都共同继承于一个父类或者有共同的接口。简单工厂模式是工厂模式家族中最简单的一种实用模式，也能够说是不一样工厂模式的一个特殊实现。

　　简单工厂符合面向对象重要原则之一：封装改变。

 

　　参与者：

　　工厂角色Creator：模式的核心，负责建立全部实例，根据传入的参数，决定建立什么类型的实例。

　　抽象产品角色Product：上述全部类的父类或者是接口。

　　具体产品角色Concrete Product：由工厂类建立出来的具体的产品实例。

 

　　UML图：

　　

 

　　举例说明：

　　列举大话设计模式中的一个计数器例子，制做一个计数器，进行加减乘除运算。

　　

　　抽象产品角色：父类（运算类）　

public class Operation
    {
        private double numberA = 0;
        private double numberB = 0;

        public double NumberA
        {
            get { return numberA; }
            set { numberA = value; }
        }

        public double NumberB
        {
            get { return numberB; }
            set { numberB = value; }
        }

        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }

　　

　　具体产品角色：子类（加减乘除）　

class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

    class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }

    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
            {
                throw new Exception("除数不能为0");
            }
            result = NumberA / NumberB;
            return result;
        }
    }

 

　　工厂角色：建造各类实例

public class OperationFactory
    {
        public static Operation CreateOperate(string operate)
        {
            Operation operation = null;

            switch (operate)
            { 
                case "+":
                    operation = new OperationAdd();
                    break;
                case "-":
                    operation = new OperationSub();
                    break;
                case "*":
                    operation = new OperationMul();
                    break;
                case "/":
                    operation = new OperationDiv();
                    break;
            }

            return operation;
        }
    }

 

　　客户端调用：　

static void Main(string[] args)
        {
            Operation operation;
            operation = OperationFactory.CreateOperate("-");
            operation.NumberA = 3;
            operation.NumberB = 7;
            double result = operation.GetResult();
            Console.WriteLine(result);

            Console.ReadLine();
        }

　　

　　到此，一个简单的计数器实例编写完毕。客户端向工厂类传入参数“-”，工厂类根据传入的参数建立具体的产品实例，而后进行运算。

 

　　简单工厂模式优势：

　　简单工厂模式解决了客户端直接依赖于具体对象的问题，客户端能够消除直接建立对象的责任，而仅仅是消费产品。　　低耦合，与外界具体产品类分开。

　　实现代码复用。

 

　　缺点：

　　违反了高内聚的原则，直接致使：若是须要建立新的类，也就必须改变工厂类。

　　

　　适用场合：

　　适用于建立的对象比较少的状况；

　　适用于客户端只负责传入参数而不关心建立实例的内部逻辑。

 

补充：

　　看的设计模式第一个就是简单工厂模式，可是实际项目中一直没有用，前几天一个同事为了解决项目问题用了简单工厂模式，过后跟他一讨论才知道，那哥们比较牛，没有看过设计模式，就是根据本身的想象写出一个小架构，符合简单工厂模式。此处只是为了加速对简单工厂模式的理解，大体讲解该项目的系统框架。

该项目是：为了集合多厂商产品SDK而开发出来的一套产品，目前仅有A和B厂商的SDK。编写简单框架，知足扩展要求，实现产品功能。

首先编写一个接口类：

interface IMethod
{
   void method1();
   void method2();      
}

其次是A和B厂商都继承IMethod接口：

class A:IMethod
{
  void method1()
  {
     //user ASDK       
   }  

   void method2()
  {
     //user ASDK       
   }      
}

class B:IMethod
{
  void method1()
  {
     //user BSDK       
   }  

   void method2()
  {
     //user BSDK       
   }  
}

 

工厂类，即决定调用什么方法：

class Factory
{
    public char factorySDK;

    public Factory(char factorySDK)
    {
         this.factorySDK = factorySDK;
    }  

    public IMethod  CreateSDK(char factorySDK)
    {
           IMethod method = null;
            switch(factorySDK)
            {
                     case ASDK:
                            method = new  A();
                             break;
                       case BSDK:
                            method = new  B();
                             break;
                      default:
                               break;
            }
            return method;
    }  

　　public void Method1()
　　{
　　　　method.Method1();
　　}

　　

　　public void Method2()
　　{
　　　　method.Method2();
　　}

}

 

　　若是下次须要把C厂商产品的SDK也集中进去，若是没有新的需求，那么便不须要增长新的方法，只须要建造一个C类，继承IMethod接口。同时在工厂类中新增一个new C便可。经过此项目，从理论方面学习设计模式进入到实际的项目实践中去，虽然是看到别人写的，但最本身也是一个不小的收获。