一、设计模式之工厂模式--简单工厂模式--创建型模式

　　简单工厂模式又叫静态工厂方法模式，是属于创建型的模式， 创建型模式简单的理解就会创建对象并返回相应的实例。简单工厂模式中分类为三个：父类、子类、工厂类。父类决定了子类的具体类别，定义子类要实现的功能;子类实现了父类的功能;工厂类决定了要创建的具体子类实例然后返回该实例。作为静态工厂的使用者只需要知道父类类别和相应的工厂类，而不是直接访问相应的子类。如下图(图片来源一键钟情)：

　　

示例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace SimpleFactory
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("有个水果店要几个水果吧:\r\n 来个苹果吧：");
            Fruit destFruit = FruitFactory.CreateFruit("Apple");
            destFruit.Response();

            Console.WriteLine("来个香蕉吧：");
            destFruit = FruitFactory.CreateFruit("Banana");
            destFruit.Response();

            Console.WriteLine("我想吃肉，来块牛肉吧：");
            destFruit = FruitFactory.CreateFruit("Meel");
            try
            {
                destFruit.Response();
            }
            catch
            {
                Console.WriteLine("水果店里木有牛肉");
            }
            Console.ReadKey();
        }
    }

    /// <summary>
    /// 水果抽象类
    /// </summary>
    public abstract class Fruit
    {

        public abstract void Response();
    }

    /// <summary>
    /// 苹果类
    /// </summary>
    public class Apple : Fruit
    {
        public override void Response()
        {
            Console.WriteLine("我是苹果\r\n");
        }
    }

    /// <summary>
    /// 桔子类
    /// </summary>
    public class Orange : Fruit
    {
        public override void Response()
        {
            Console.WriteLine("我是桔子\r\n");
        }
    }

    /// <summary>
    ///香蕉类
    /// </summary>
    public class Banana : Fruit
    {
        public override void Response()
        {
            Console.WriteLine("我是香蕉\r\n");
        }
    }

    /// <summary>
    /// 工厂类：水果店
    /// </summary>
    public class FruitFactory
    {
        public static Fruit CreateFruit(string kind)
        {
            Fruit destFruit;
            switch (kind)
            {
                case "Apple":
                    destFruit = new Apple();
                    break;
                case "Orange":
                    destFruit = new Orange();
                    break;
                case "Banana":
                    destFruit = new Banana();
                    break;
                default:
                    destFruit = null;
                    break;
            }

            return destFruit;
        }
    }
}

运行结果如下：

　　示例解析：示例中父类是Fruit类，定义了决定了子类的类别只能是水果。三个子类Apple、Orange、Banana类是水果的子类，实现了水果类的响应功能。FruitFactory工厂类的static方法CreateFruit跟据传入的字符串返回相应的水果实例。最后想要牛肉的异常就是没有搞清父类类别和水果工厂的功能才去水果工厂要牛肉，这事非常扯。

　　简单工厂模式的优缺点：

　　优点：在调用的地方不需要负责类的实例化，类创建是由工厂类来返回相应的实例从而达到实例化的结果。

　　缺点：简单工厂模式是静态方法来创建的，所以这个工厂类无法被继承，如果要频繁的通过这个工厂类来实现化， 这个类会非常庞大， 不利于维护。如果有新了子类加入就要重新修改工厂类的逻辑，容易导致混乱发生错误。