设计模式学习笔记四:简单工厂模式\抽象工厂模式\工厂方法模式

一.简单工厂模式:

　　1.简介

　　　　简单工厂模式(Simple Factory Pattern):又称静态工厂方法(Static Factory Method)模式,专门定义一个类负责创建其他类的实例,被创建的实例通常都具有相同的父类,可以根据参数指定创建的类实例.

　　2.简单工厂模式实现类图:

 

　　3.简单工厂模式实现(C#)

/************************************
* 创建人：movin
* 创建时间：2021/8/7 11:54:56
* 版权所有：个人
***********************************/
using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatternsCore
{
    /// <summary>
    /// 简单工厂
    /// </summary>
    public class SimpleFactory
    {
        /// <summary>
        /// 工厂创建方法
        /// </summary>
        /// <param name="productType"></param>
        /// <returns></returns>
        public ISimpleFacroryProduct Create(ESimpleFactoryProductType productType)
        {
            switch (productType)
            {
                case ESimpleFactoryProductType.A:
                    return new SimpleFactoryProductA();
                case ESimpleFactoryProductType.B:
                    return new SimpleFactoryProductB();
                default:
                    return null;
            }
        }
    }
    /// <summary>
    /// 工厂产品接口
    /// </summary>
    public interface ISimpleFacroryProduct
    {
        void Print();
    }
    /// <summary>
    /// 产品A
    /// </summary>
    public class SimpleFactoryProductA : ISimpleFacroryProduct
    {
        public void Print()
        {
            Console.WriteLine("product a");
        }
    }
    /// <summary>
    /// 产品B
    /// </summary>
    public class SimpleFactoryProductB : ISimpleFacroryProduct
    {
        public void Print()
        {
            Console.WriteLine("product b");
        }
    }
    /// <summary>
    /// 产品类型
    /// </summary>
    public enum ESimpleFactoryProductType
    {
        A,
        B,
    }
}

　　4.总结:简单工厂模式直观地呈现了工厂模式的创建方式,非常有助于理解工厂模式,也非常容易理解,但是这个工厂模式对创建类对象仍然对对象创建不够友好,当我们要拓展一种新的产品时,需要定义好新的产品子类\新的枚举类型,尤其是还要在工厂的创建方法中添加相应的条件分支语句,我们还是希望能不改动创建工厂实现产品的拓展,显然简单工厂模式很难实现这个需求.

二.工厂方法模式

　　1.概念:

　　　　工厂方法模式(Factory Method),定义了一个创建对象的接口,让字类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其字类.

　　　　工厂方法模式可以理解为在简单工厂模式的基础上的拓展.简单工厂模式违背了开闭原则,

　　2.工厂方法模式实现类图

　　3.工厂方法模式实现

/************************************
* 创建人：movin
* 创建时间：2021/8/7 11:54:56
* 版权所有：个人
***********************************/
using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatternsCore
{
    /// <summary>
    /// 工厂接口
    /// </summary>
    public interface IFactoryMethod
    {
        IFactoryMethodProduct Create();
    }
    /// <summary>
    /// 工厂A
    /// </summary>
    public class FactoryMethodA : IFactoryMethod
    {
        /// <summary>
        /// 工厂创建方法
        /// </summary>
        /// <param name="productType"></param>
        /// <returns></returns>
        public IFactoryMethodProduct Create()
        {
            return new FactoryMethodProductA();
        }
    }
    /// <summary>
    /// 工厂B
    /// </summary>
    public class FactoryMethodB : IFactoryMethod
    {
        public IFactoryMethodProduct Create()
        {
            return new FactoryMethodProductB();
        }
    }
    /// <summary>
    /// 工厂产品接口
    /// </summary>
    public interface IFactoryMethodProduct
    {
        void Print();
    }
    /// <summary>
    /// 产品A
    /// </summary>
    public class FactoryMethodProductA : IFactoryMethodProduct
    {
        public void Print()
        {
            Console.WriteLine("product a");
        }
    }
    /// <summary>
    /// 产品B
    /// </summary>
    public class FactoryMethodProductB : IFactoryMethodProduct
    {
        public void Print()
        {
            Console.WriteLine("product b");
        }
    }
}

        static void Main(string[] args)
        {
            //使用时决定创建哪个工厂
            IFactoryMethod factorya = new FactoryMethodA();
            IFactoryMethodProduct producta = factorya.Create();
            producta.Print();

            IFactoryMethod factoryb = new FactoryMethodB();
            IFactoryMethodProduct productb = factoryb.Create();
            productb.Print();

            Console.ReadKey();
        }

三.抽象工厂模式

　　1.概念

　　　　抽象工厂模式(Abstract Factory):提供了一个创建一系列相关或互相依赖对象的接口,而无需指定它们具体的类.

　　　　抽象工厂模式可以理解为是工厂方法模式的进一步拓展,工厂方法模式中的工厂只能生产一种产品,但是抽象工厂模式中的工厂可以生产多种产品..

　　2.抽象工厂模式实现类图

　　3.抽象工厂模式实现代码:

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

namespace DesignPatternsCore
{
    /// <summary>
    /// 工厂接口
    /// </summary>
    public interface IAbstractFactory
    {
        IAbstractFactoryProduct Create1();
        IAbstractFactoryProduct Create2();    
    }
    /// <summary>
    /// 工厂A
    /// </summary>
    public class AbstractFactoryA : IAbstractFactory
    {
        /// <summary>
        /// 工厂创建方法
        /// </summary>
        /// <param name="productType"></param>
        /// <returns></returns>
        public IAbstractFactoryProduct Create1()
        {
            return new AbstractFactoryProductA1();
        }

        public IAbstractFactoryProduct Create2()
        {
            return new AbstractFactoryProductA2();
        }
    }
    /// <summary>
    /// 工厂B
    /// </summary>
    public class AbstractFactoryB : IAbstractFactory
    {
        public IAbstractFactoryProduct Create1()
        {
            return new AbstractFactoryProductB1();
        }

        public IAbstractFactoryProduct Create2()
        {
            return new AbstractFactoryProductB2();
        }
    }
    /// <summary>
    /// 工厂产品接口
    /// </summary>
    public interface IAbstractFactoryProduct
    {
        void Print();
    }
    /// <summary>
    /// 产品A1
    /// </summary>
    public class AbstractFactoryProductA1 : IAbstractFactoryProduct
    {
        public void Print()
        {
            Console.WriteLine("product a1");
        }
    }
    /// <summary>
    /// 产品A2
    /// </summary>
    public class AbstractFactoryProductA2 : IAbstractFactoryProduct
    {
        public void Print()
        {
            Console.WriteLine("product a2");
        }
    }
    /// <summary>
    /// 产品B1
    /// </summary>
    public class AbstractFactoryProductB1 : IAbstractFactoryProduct
    {
        public void Print()
        {
            Console.WriteLine("product b1");
        }
    }
    /// <summary>
    /// 产品B2
    /// </summary>
    public class AbstractFactoryProductB2 : IAbstractFactoryProduct
    {
        public void Print()
        {
            Console.WriteLine("product b2");
        }
    }
}

        static void Main(string[] args)
        {
            //使用时决定创建哪个工厂
            IAbstractFactory factorya = new AbstractFactoryA();
            IAbstractFactoryProduct producta1 = factorya.Create1();
            producta1.Print();
            IAbstractFactoryProduct producta2 = factorya.Create2();
            producta2.Print();

            IAbstractFactory factoryb = new AbstractFactoryB();
            IAbstractFactoryProduct productb1 = factoryb.Create1();
            productb1.Print();
            IAbstractFactoryProduct productb2 = factoryb.Create2();
            productb2.Print();

            Console.ReadKey();
        }

四.改进

　　尽管抽象工厂模式和工厂方法模式都没有违背开闭原则,但是还是需要使用者在使用时创建具体的工厂,这就意味着使用者一定程度上还是需要了解实现细节(至少要了解有哪些工厂)才能使用,这个问题我们将简单工厂模式和抽象工厂模式结合起来,借助于配置文件的方式实现.我们不再需要抽象工厂和具体的工厂实现类,只需要一个创建工厂,然后使用配置文件的方式配置我们要创建的产品,使用反射的方式获取要创建的产品类.当需要改变创建的产品时只需要修改配置文件即可.