通俗易懂设计模式解析——工厂模式（Factory Method）

前言

　　上一篇咱们介绍了单例模式，今天给你们讲一个比较简单的模式——工厂模式（Factory Method），工厂模式又是什么呢？顾名思义，工厂——生产制造东西的地方。那么应用在程序当中该如何使用、而且又起到什么效果呢？以致于为何用工厂模式呢？

　　以前咱们说的OCP原则（开放封闭原则），对扩展开放，对修改封闭这一原则。在工厂模式中有极好的体现，对对象及类进行极好的封装。使其减小代码之间的耦合性。更具备扩展性。

工厂模式介绍

1、来由

　　在咱们编程过程中，总会面临一些类的建立以及对象的建立，可是因为需求而不断变更（增长或者修改），致使对象的变化。这时怎么处理这个问题呢？

工厂模式提供的一种封装机制，隔离出了那些易变更的对象。这个时候需求的变更再也不影响以前的对象的变更了。

2、意图

　　定义一个用于建立对象的接口，让子类决定实例化哪个类。FactoryMethod使一个类的实例化延迟到其子类。

3、案例图

 

 

工厂模式中由如下部分组成：

（1）、抽象工厂（Creator）: 复制定义工厂所需的基本规则，其余任何具体工厂都得继承此抽象工厂

（2）、具体工厂（Concrete_Creator）：继承抽象工厂，实现其定义的方法，以此来建立具体的产品

（3）、抽象产品（Product）：复制定义产品的基本方法及规则，全部具体产品都得基础此抽象产品类

（4）、具体产品（Concrete_Product）：继承抽象产品，实现其定义抽象方法，由具体工厂建立，二者是一一对应的关系。

4、工厂模式代码实现

这里咱们经过一个事例来介绍工厂模式的规则及用法。在工厂模式中，定义抽象工厂，而后其具体工厂继承实现其抽象方法调用继承了抽象产品类的具体产品来建立产品。

 

 

 

下面咱们就手机产品的制造来看看下面的事例吧：

namespace ConsoleApp4
{
   public  class Factory_Method_Pattern
    {
    }
    #region  产品 =========================
    /// <summary>
    /// 抽象手机产品类
    /// </summary>
    public abstract class Phone
    {
        public abstract string Create();
    }

    /// <summary>
    /// 具体华为手机产品类
    /// </summary>
    public class Huawei : Phone
    {
        /// <summary>
        /// 实现抽象方法
        /// </summary>
        /// <returns></returns>
        public override string Create()
        {
            return "华为一号现世";
        }
    }

    /// <summary>
    /// 具体小米手机产品类
    /// </summary>
    public class Xiaomi : Phone
    {
        /// <summary>
        /// 实现抽象方法
        /// </summary>
        /// <returns></returns>
        public override string Create()
        {
            return "小米一号现世";
        }
    }

    #endregion

    #region  工厂=========================
    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class Factory
    {
        /// <summary>
        /// 抽象工厂类的方法，建立调用产品
        /// </summary>
        /// <returns></returns>
        public abstract Phone CreatePhone();
    }

    /// <summary>
    /// 具体华为工厂类，继承抽象工厂类
    /// </summary>
    public class HuaweiFactory : Factory
    {
        /// <summary>
        /// 实现继承方法
        /// </summary>
        /// <returns></returns>
        public override Phone CreatePhone()
        {
            return new Huawei();
        }
    }

    /// <summary>
    /// 具体小米工厂类，继承抽象工厂类
    /// </summary>
    public class XiaomiFactory : Factory
    {
        /// <summary>
        /// 实现继承方法
        /// </summary>
        /// <returns></returns>
        public override Phone CreatePhone()
        {
            return new Xiaomi();
        }
    }
    #endregion 
}

 

 class Program
    {
        static void Main(string[] args)
        {
            //初始化工厂
            Factory huaweiFactory = new HuaweiFactory();
            
            //生产具体的华为手机
            var result=huaweiFactory.CreatePhone();
            //华为手机现世
            var answer = result.Create();
            Console.WriteLine(answer);

            Factory xiaomiFactory = new XiaomiFactory();
            result = xiaomiFactory.CreatePhone();
            answer = result.Create();
            Console.WriteLine(answer); 

            Console.ReadLine();
        }
    }

 

　　在上述事例中，一样是先把手机抽象出一个抽象类，手机固然也不是凭空出现的。因此须要再抽象一个工厂类。工厂类派生子类不一样的手机厂商类。一样手机也派生了不同的品牌。手机厂商类再对应手机品牌去生产相应的手机。这时咱们须要增长一个手机手机品牌，咱们不须要去修改工厂类及产品类。咱们另外新增便可。彻底不影响其原来的运行。好比咱们须要新增魅族手机。

    #region 新增魅族手机 ================
    /// <summary>
    /// 新增魅族工厂类
    /// </summary>
    public class MeizuFactory : Factory
    {
        public override Phone CreatePhone()
        {
            return new Meizu();
        }
    }

    /// <summary>
    /// 新增具体魅族手机产品类
    /// </summary>
    public class Meizu : Phone
    {
        public override string Create()
        {
            return "魅族一号现世";
        }
    }
    #endregion

 

在客户端调用时增长如下调用就能够了

            Factory meizuFactory = new MeizuFactory();
            result = meizuFactory.CreatePhone();
            answer = result.Create();
            Console.WriteLine(answer);

使用场景及优缺点

在此模式中，将全部要建立的具体对象的工做都延迟放在了子类中去实现，实现了一种扩展的策略。与OCP原则相对应。

工厂模式主要针对解决的是”单个对象”的问题。隔离类的对象的使用者与具体类型之间的耦合关系。去实现了必定程度的解耦。

（一）使用场景

一、当用户不须要知道产品的类名的时候或者不关心如何建立的时候。咱们只须要知道建立它的具体工厂的时候。

二、将建立对象的任务委托给多个工厂中的一个，客户端使用的时候无需关心是哪个建立产品。当须要动态指定。

（二）优势

一、在编程方法中，客户端调用不须要知道产品的具体工厂，也不须要关心如何建立的。

二、在增长需求的时候，增长产品的时候仅须要新增一个工厂类及产品类便可，不须要对原来的代码进行修改。可轻易的扩展。

（三）缺点

在增长产品的时候，额外的增长了工厂类及产品类。增长一个产品增长两个类。在必定程度上增长了系统的复杂度。同时也加强了类之间的依赖性。这也就是其中很差的问题

总结

　　每个设计模式都有对应的使用场合，切勿滥用。在咱们学习设计模式的同时，咱们也须要以其原主要则做为基准学习。万万不能违背原则。在设计模式——工厂模式中，将建立对象的任务委托给其工厂子类、延迟执行。解决了系统难于扩展的问题，同时也减小了具体类与对象之间的耦合性。也实现了开放扩展封闭修改的原则。

　　这个社会是存在不公平的，不要抱怨，由于没有用！人老是在检讨中进步的！

　　C#设计模式系列目录

 

欢迎你们扫描下方二维码，和我一块儿踏上设计模式的闯关之路吧!