设计模式-简单工厂

定义

百度文库：简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

标准定义：简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式（Static FactoryMethod Pattern）,是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

基本简介

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一类产品(这些产品继承自一个产品的父类或者接口)的实例，该模式包含的角色和职责。

(1)工厂（Creator）角色

简单工厂模式的核心，他负责实现创建所有实例的内部逻辑。工厂类的创建产品类方法可以直接被外界调用，创建所需的产品对象。

(2)抽象产品（Product）角色

简单工厂模式所创建所有对象的父类，他负责描述所有实例所共有的公共接口。

(3)具体产品（Concrete Product）角色

简单工厂模式的创建目标，所有创建的对象都是充当这个角色某个具体类的实例。

UML图

示例1

抽象产品的简单工厂

(1.1)抽象产品

     /// <summary>
    /// 抽象产品
    /// </summary>
    public abstract class Product
    {
        public abstract void Create();
    }

(1.2)具体产品ProductA,ProductB

    /// <summary>
    /// 具体产品A
    /// </summary>
    public class ProductA : Product
    {
        public override void Create()
        {
            Console.WriteLine("create product_A");
        }
    }

    /// <summary>
    /// 具体产品B
    /// </summary>
    public class ProductB : Product
    {

        public override void Create()
        {
            Console.WriteLine("create product_B");
        }
    }

(1.3)工厂创建

    /// <summary>
    /// 工厂类，根据参数判断创建何种实例
    /// </summary>
    public class CreateFactory
    {
        public static Product InstanceCreater(string type)
        {
            switch (type)
            {
                case "ProductA":
                    return new ProductA();
                case "ProductB":
                    return new ProductB();
                default:
                    throw new NotImplementedException();
            }
        }
    }

(1.4)实例调用

 Product product = CreateFactory.InstanceCreater("ProductA");

示例2

(2.1)概念产品计算器类

     /// <summary>
    /// 计算类
    /// </summary>
    public class Operation
    {
        /// <summary>
        /// 数字A
        /// </summary>
        public double NumberA { get; set; }
        /// <summary>
        /// 数字B
        /// </summary>
        public double NumberB { get; set; }

        /// <summary>
        /// 得到运算结果
        /// </summary>
        /// <returns></returns>
        public virtual double CalcResult()
        {
            double result = 0;
            return result;
        }
    }

（2.2）具体操作eg:加法，减法

     /// <summary>
    /// 加法类
    /// </summary>
    public class OperationAdd : Operation
    {
        public override double CalcResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

    /// <summary>
    /// 减法类
    /// </summary>
    public class OperationSub : Operation
    {
        public override double CalcResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

（2.3）工厂计算器方法

     /// <summary>
    /// 工厂计算方法类
    /// </summary>
    public class OperationFactory
    {
        public static Operation GetOperationInstance(string operate)
        {
            Operation opera = null;
            switch (operate)
            {
                case "+":
                    opera = new OperationAdd();
                    break;
                case "-":
                    opera = new OperationSub();
                    break;
                default:
                    throw new NotImplementedException();
            }
            return opera;
        }
    }

(2.4)调用

     Operation operation = OperationFactory.GetOperationInstance("+");
     operation.NumberA = 10;
     operation.NumberB = 10;
     Console.WriteLine(operation.CalcResult());        

　　

深入分析

简单工厂解决的问题是如何如何去实例化一个合适的对象

简单工厂核心思想有一个专门的类负责创建实例的过程

具体来说把产品看成一系列类的集合，这些类是由某个抽象类或者接口派生出来的一个对象树，而工厂类用来产生一个合适的对象满足客户的需求。如果简单工厂模式所涉及的具体产品之间没有共同的逻辑，那么我们就可以使用接口来扮演抽象产品的角色，如果具体产品之间有相似的功能或逻辑，我们就把这些相似的逻辑提取出来放到抽象类中。然后具体产品继承抽象类，为了实现更好的复用，共同或者重复的东西应该抽象出来。

优缺点

(1)优点

工厂类是整个模式的关键所在，它包含必要的判断逻辑，能够根据外界的指定条件实例化相应具体产品，用户在使用时可以直接根据工厂类创建所需要的实例，无需了解对象是如何创建以及如何组织的。有利于软件结构体系优化。

(2)缺点

由于工厂类集中了所有类的创建逻辑，这就导致一旦这个工厂出现问题，所有的客户端都收到牵连。由于简单工厂模式的产品基于一个共同的抽象类后者接口，这样一来，当产品种类增加的时候

总结：

简单工厂模式分离产品的创建者和消费者,有利于软件系统的机构化;但犹豫一切逻辑都集中在工厂类中，导致了没有很高的内聚性，同时也违背了开放封闭原则。另外，简单工厂模式的方法一般是静态的，而静态工厂方法是无法让子类继承的,因此简单工厂无法形成基于基类的继承树结构。