设计模式 建立型-工厂模式

定义

工厂模式是为建立对象提供接口，以便把建立对象的具体过程隔离起来，封装变化，提升建立的通用性。

 

分类

工厂模式包含如下三种分类：

• 简单工厂
• 工厂模式
• 抽象工厂

 

简单工厂

简单工厂又叫静态工厂方法（Static Factory Method），它是把产品的建立移到统一的工厂方法中去，而不是把产品建立依赖具体产品使用new来建立。

 

类图以下：

 

 

 

 

场景：咱们须要生产共享单车，目前市场上有膜拜单车与小黄车两种产品可供选择。市场上有家代理生产自行车工厂就叫 SimpleBikeFactory,只要给它单车标签，他就会按要求生产膜拜单车或小黄车。

若是那天要生产小绿车， SimpleBikeFactory 只要调整他中的逻辑，就能够知足须要了。

 

• 代码

namespace hbb0b0.DesignPattern
{
    /// <summary>
    /// 自行车接口
    /// </summary>
    public interface IBike
    {

    }

    /// <summary>
    /// 膜拜单车
    /// </summary>
    public class MoBike : IBike
    {
        public MoBike()
        {
            Console.WriteLine("MoBike");
        }
    }

    /// <summary>
    /// 小黄车
    /// </summary>
    public class OfOBike : IBike
    {
        public OfOBike()
        {
            Console.WriteLine("OfOBike");
        }
    }

    /// <summary>
    /// 简单单车生产工厂
    /// </summary>
    public class SimpleBikeFactory
    {
        public static IBike GetBike(string bikeName)
        {
            switch (bikeName)
            {
                case "MO":
                    return new MoBike();
                
                case "OFO":
                    return new OfOBike();
                    
                default:
                    return new MoBike();
                    
            }
        }
    }
}

namespace hbb0b0.DesignPattern.SimpleFactory
{
    /// <summary>
    /// SimpleFactoryApp
    /// </summary>
    public class SimpleFactoryApp : IMain
    {
        public void Test()
        {
            //建立膜拜单车
            IBike moBike = SimpleBikeFactory.GetBike("MO");

            //建立小黄车
            IBike ofoBike = SimpleBikeFactory.GetBike("OFO");
        }
    }
}

 

• 优势

原本生产单车的代码

小黄车 OfOBike ofoBike =new OfOBike();

膜拜单车 MoBike moBike = new MoBike();

如今把生产单车对具体单车的依赖移到了静态工厂方法，封装了建立单车的变化，避免了建立单车代码分散到各个地方，便于单车建立逻辑的维护与修改。

 

• .net 中的使用

 

Encoding 中的 GetEncoding方法就是简单工厂，它就是根据传入标识来肯定生成那种Encoding。

 

 

工厂方法模式：

为建立对象定义一个接口，让子类来决定哪个类须要进行实例化，工厂模式容许一个类把实例化过程委托给子类。

 

类图

 

 

 

 

代码以下：

namespace hbb0b0.DesignPattern.FactoryMethod
{
    /// <summary>
    /// 单车接口
    /// </summary>
    public interface IBike
    {
    }
    /// <summary>
    /// 膜拜单车
    /// </summary>
    public class MoBike:IBike
    {
    }
    /// <summary>
    /// 小黄车
    /// </summary>
    public class OfOBike:IBike
    {
    }

    /// <summary>
    /// 单车工厂接口
    /// </summary>
    public interface IBikeFactory
    {
        /// <summary>
        /// 获取单车
        /// </summary>
        /// <returns></returns>
        IBike GetBike();
    }
   /// <summary>
    /// 膜拜单车工厂
    /// </summary>
    public class MoBikeFactory : IBikeFactory
    {
        public IBike GetBike()
        {
            return new MoBike();
        }
    }
   /// <summary>
    /// 小黄车工厂
    /// </summary>
    public class OfOBikeFactory : IBikeFactory
    {
        public IBike GetBike()
        {
            return new OfOBike();
        }
    }
}

 

使用

namespace hbb0b0.DesignPattern.AbstractFactory
{
    public class AbstractFactoryApp : IMain
    {
        public void Test()
        {

            //生产膜拜系列产品：单车与电动车
            IBikeFactory moFactory = new MoBikeFactory();
            
            IBike moBike=  moFactory.GetBike();
            IElectricBike moElectric =  moFactory.GetElectricBike();

            //生产小黄车系列产品：单车与电动车
            IBikeFactory ofoFactory = new OfOBikeFactory();
            IBike ofoBike = ofoFactory.GetBike();
            IElectricBike ofoElectric = ofoFactory.GetElectricBike();

        }
    }
}

 

 

.net 使用工厂模式

 

 

 

抽象工厂：

定义为建立相关或具备依赖关系的对象族提供一个接口，而无需分别为这些对象指定具体的类。

抽象工厂容许客户使用抽象的接口来建立一组相关产品，而不须要知道或关心实际生产出的具体产品是什么。

 

 

 

 

 

代码

namespace hbb0b0.DesignPattern.AbstractFactory
{
    /// <summary>
    /// 电动车接口
    /// </summary>
    public interface IElectricBike
    {
    }

/// <summary>
    /// 抽象工厂
    /// （提供多种产品）
    /// </summary>
    public interface IBikeFactory
    {
        /// <summary>
        /// 获取自行车接口
        /// </summary>
        /// <returns></returns>
        IBike GetBike();

        /// <summary>
        /// 获取电动车接口
        /// </summary>
        /// <returns></returns>
        IElectricBike GetElectricBike();
    }
}
    /// <summary>
    /// 膜拜自行车工厂
    /// </summary>
    public class MoBikeFactory : IBikeFactory
    {
        public IBike GetBike()
        {
            return new MoBike();
        }

        public IElectricBike GetElectricBike()
        {
            return new MoElectricBike();
        }
    }
}
    
    //小黄车自行车工厂
    public class OfOBikeFactory : IBikeFactory
    {
        public IBike GetBike()
        {
            return new OfOBike();
        }

        public IElectricBike GetElectricBike()
        {
            return  new OfOElectricBike();
        }
    }
}

 

 

使用

 

namespace hbb0b0.DesignPattern.AbstractFactory
{
    public class AbstractFactoryApp : IMain
    {
        public void Test()
        {

            //生产膜拜系列产品：单车与电动车
            IBikeFactory moFactory = new MoBikeFactory();
            
            IBike moBike=  moFactory.GetBike();
            IElectricBike moElectric =  moFactory.GetElectricBike();

            //生产小黄车系列产品：单车与电动车
            IBikeFactory ofoFactory = new OfOBikeFactory();
            IBike ofoBike = ofoFactory.GetBike();
            IElectricBike ofoElectric = ofoFactory.GetElectricBike();

        }
    }
}

 

• .net 应用

 

 

 

三者区别：

简单工厂模式：是把产品建立统移到统一的工厂方法中去，从而解耦了产品的建立依赖具体的产品。

工厂模式：为建立对象定义一个接口，而由子类决定产品的建立。对象的建立是在子类中完成。

抽象工厂模式：为某一系列或具备依赖关系的产品建立定义接口，而不须要分别为各个产品的建立指定具体的类。工厂模式只提供单一产品，抽象工厂是对工厂模式的升级，抽象工厂是在工厂模式的基础上提供一系列或具备依赖关系的商品。