工厂模式

多态的概念：指同一对象在执行不同的操作的时候产生的不同的结果。及多态的出现就是为了增加代码的扩展性，可维护性、灵活性和可替换性。为了增加代码的扩展性，我们有个多态这个概念。举个栗子

1. 比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。

在理解多态的我们先来了解里氏替换原则和开放封闭原则：       

也就是说我们可以将所有的子类型都当做父类类型来看，在具体用到哪个子类的时候产生哪个子类。这样生产出的子类就很灵活。

有了对多态的了解以后，我们看看一个栗子：

 常规的对象创建方法(比如创建一个计算器类)：

  Calculator cal=new Calculator();

  new 的问题，实现依赖，不能应对“具体实例化类型”的变化，也就是说不利于后期的扩展和维护，每次只能new出固定的对象。
 解决思路：
  ，封装变化点，哪里变化，封装哪里。每次在创建的时候，我们就只需要根据封装的代码来进行调用，而不需要从头改到尾。

解决办法：

    依赖接口，而非依赖实现，变化点在对象创建。我们要扩展的部分是对象创建，所以封装对象创建部分。就是说软件的设计应该是从紧耦合向松耦合设计的过程，对于不变的部分，我们不去管，对于需要变化或者扩展的部分，我们应该封装起来。

我们把计算器写成一个接口类，因为计算器的计算方法在变化，计算结果因为计算方法的不同而变化：

  interface Calculator
       {
         public Calculator()
         {

         }
         public double GetResult();

        }

  这里我们使用一个工厂类来产生我们需要的对象：

class Calculatorfactory
    {
        public static Calculator CreateFactory(string type,double x,double y)
        {
            Calculator cal = null;
            switch (type)
            {
                case "+":
                cal = new add(x,y);
                break;
                case "_":
                cal = new sub(x,y);
                break;
                case "*":
                cal = new mult(x,y);
                break;
                case "/":
                cal = new div(x,y);
                break;
            }
            return cal;
        }
    }

现在对象的产生不在依耐于具体类，而依赖于抽象类了。我们想产生一个加的方法，则：

class add:Calculator
    {
        public double x;
        public double y;
        public add(double x,double y)
        {
            this.x = x;
            this.y = y;
        }
        public  double GetResult()
        {
            return x + y;
        }
    }

产生一个乘的方法，则：

class mult:Calculator
    {
        public double x;
        public double y;
        public mult(double x,double y)
        {
            this.x = x;
            this.y = y;
        }
        public  double GetResult()
        {
            return x *y;
        }
    }

如果我们还想产生其他种类的计算方法，只需要继承计算器这个接口修改相应的子类就行了。在主函数中调用，我们就可以根据不同的计算需求产生不同的计算方法，函数的扩展性大大提高了。：

 static void Main(string[] args)
        {
            Calculator ca = Calculatorfactory.CreateFactory("+", 1, 2);
            double x=ca.GetResult();
            Console.WriteLine(x);
            Console.ReadKey();
        }

当然这个设计模式有他的弊端，在下一篇抽象工厂中将指出并解决这个问题。