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

说到这几个工厂模式有很多相似之处又有不同。最重要的是掌握这种思想，在以后搭建项目架构或写一些功能，应用这些思想，让自己的程序更健壮，或者说当你看到别人写的程序应用到了这种思想能够快速理解。话不多说，咱们先从入门级的小案例讲起。

一.简单工厂模式

基本概念:简单工厂模式是由一个工厂类根据接受到的消息决定要创建哪一个类的对象实例。

优点：在客户端只需要告诉工厂类创建什么实例就行，而不要关注具体怎么创建，因为那个工厂类有相关逻辑。

缺点:当添加新产品就不得不修改工厂逻辑，当类型较多时，可能造成工厂逻辑比较复杂，不利于系统的扩展和维护，所以从工厂的角度来说简单工厂模式是不符合软件设计原则的开闭原则(对扩展开放,对修改关闭)。

我们通过教科书级别的例子辅助理解代码如下:

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

namespace SimpleFactory
{
    class Program
    {
        static void Main(string[] args)
        {
            FlyFactory flyFactory = new FlyFactory();
            flyFactory.GetFly("wuya").fly();
            flyFactory.GetFly("yingwu").fly();
            Console.ReadKey();   
        }
    }
    public interface IFly
    {
        void fly(); //默认公用方法
    }

    public class Wuya : IFly
    {
        public void fly()
        {
            Console.WriteLine("我是一只黑呜呜的乌鸦鸟，我会飞!");
        }
    }
    public class YingWu : IFly
    {
        public void fly()
        {
            Console.WriteLine("我是一只美丽的鹦鹉鸟,我会飞!");
        }
    }
    public class FlyFactory //飞的工厂类
    {
        public IFly GetFly(string type)
        {
            if ("wuya" == type)
            {
                return new Wuya();
            }
            else if ("yingwu" == type)
            {
                return new YingWu();
            }
            else
            {
                return null;
            }

        }

    }
}

二.工厂模式
基本概念:定义一个创建对象的工厂接口，子类继承这个接口，让子类决定实例的创建。
优点：子类继承创建对象的接口，让子类决定具体实例化的对象，想要增加一个产品，只需要增加一个工厂类即可，克服了简单工厂所违背的的开闭原则的缺点，扩展性高，易于维护.
缺点:代码量会比简单工厂多了几行，对与一些稍微复杂的业务，种类太多不太适合。

我们通过教科书级别的例子辅助理解代码如下:

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

namespace Factory
{
    class Program
    {
        static void Main(string[] args)
        {
            IFkyFactory wuYaFactory = new WuYaFatory();
            wuYaFactory.GetFly().fly();
            IFkyFactory yingWuFactory = new YingWuFactory();
            yingWuFactory.GetFly().fly();
            Console.ReadKey();
        }
    }
    public interface IFly
    {
        void fly();
    }
    public class Wuya : IFly
    {
        public void fly()
        {
            Console.WriteLine("我是一只乌鸦鸟，我会飞！");
        }
    }
    public class YingWu : IFly
    {
        public void fly()
        {
            Console.WriteLine("我是一只美丽的鹦鹉鸟，我会飞!");
        }
    }

    public interface IFkyFactory
    {
        IFly GetFly();
    }
    public class WuYaFatory : IFkyFactory
    {
        public IFly GetFly()
        {
            return new Wuya();
        }

    }
    public class YingWuFactory : IFkyFactory
    {
        public IFly GetFly()
        {
            return new YingWu();
        }
    }
}

三.抽象工厂模式
基本概念:提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

优点: 具有 工厂模式解耦的特点，此外当一个产品族中的多个对象被设计在一起工作时，它能保证客户端始终只使用同一个产品族中的对象。工厂方法模式针对的是一个产品等级结构，抽象工厂模式针对的是面向多个产品等级结构，最主要的是可以在类的内部对产品族的关联关系进行定义和描述。

缺点:虽然满足各种软件设计原则的优点，但是代码相对会多一些。

代码帮助理解，我们通过生产苹果手机，华为手机的主板，屏幕的例子如下:

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

namespace AbstractFactoryDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            IMobileFactory huaWeiMobileA = new ProductHuaWeiMobile();
            Console.WriteLine("我是第一 一个华为手机，我拥有:"); //如果你想批量生产手机可以循环语句控制
            huaWeiMobileA.ProductMobileBoard().ProductMobileBoard();
            huaWeiMobileA.ProductMobileScreen().ProductMobileScreen();
            IMobileFactory appleMobileX = new ProductAppleMobile();
            Console.WriteLine("我是第一个苹果手机,我拥有：");
            appleMobileX.ProductMobileBoard().ProductMobileBoard();
            appleMobileX.ProductMobileScreen().ProductMobileScreen();
                Console.ReadKey();
            
        }
    }
    public interface IMobileScreen
    {
        void ProductMobileScreen(); //默认公用方法
    }
    public class AppleMobileScreen : IMobileScreen
    {
        public void ProductMobileScreen()
        {
            Console.WriteLine("苹果手机屏幕");
        }
    }
    public class HuaWeiMobileScreen : IMobileScreen
    {
        public void ProductMobileScreen()
        {
            Console.WriteLine("华为手机屏幕");
        }
    }
    public interface IMobileBoard
    {
        void ProductMobileBoard();
    }

    public class AppleMobileBoard : IMobileBoard
    {
        public void ProductMobileBoard()
        {
            Console.WriteLine("苹果手机主板");
        }
    }
    public class HuaWeiMobileBoard : IMobileBoard
    {
        public void ProductMobileBoard()
        {
            Console.WriteLine("华为手机主板");
        }
    }
    public interface IMobileFactory   //生产 手机的接口
    {
        IMobileScreen ProductMobileScreen();
        IMobileBoard ProductMobileBoard();

    }
    public class ProductHuaWeiMobile : IMobileFactory //生产华为手机的工厂类
    {
        public IMobileBoard ProductMobileBoard()
        {
            return new HuaWeiMobileBoard();
        }

        public IMobileScreen ProductMobileScreen()
        {
            return new HuaWeiMobileScreen();
        }
    }
    public class ProductAppleMobile:IMobileFactory//生产苹果手机的工厂类
    {
        public IMobileBoard ProductMobileBoard()
        {
            return new AppleMobileBoard();
        }

        public IMobileScreen ProductMobileScreen()
        {
            return new AppleMobileScreen();
        }
    }
}

总结:

 朋友呀!如果看了代码还没理解这三种设计模式，建议先巩固一下C#中的面向对象中的多态，继承等基础知识或其它面向对象语言也可。这几个例子其实浅显易懂，只是让大家理解这种思想。在今后项目实战中能够应用使自己的程序更健壮，或见其他人项目中应用到了这种模式能够快速理解。