设计模式（十六）之抽象工厂模式

关于工厂模式，我们之前说过了工厂模式，简单工厂模式。

这篇日志，我们来说一下抽象工厂模式，那么，何为抽象工厂模式呢？

抽象工厂模式：提供一个创建一系列相关或互相依赖对象的接口，而无需指定他们具体的类

下面我们来写一个简单的小例子，之后，我们再分析抽象工厂模式的优缺点及三种工厂模式各自的特点。

以德国大众集团为例，他生产奥迪和大众汽车，其二者所使用的发动机和变速器都是截然不同的。那这样说来，实现这个例子。需要

抽象工厂类：AbstractFactory.cs 含有发动机接口与变速器接口，返回其二者各自的对象
抽象发动机类：AbstractEngine.cs
抽象变速器类：AbstractSpeed.cs
奥迪发动机类：AudiEngine.cs
大众发动机类：DasEngine.cs
奥迪变速器类：AudiSpeed.cs
大众变速器类：DasSpeed.cs
奥迪汽车类：AudiCar.cs
大众汽车类：DasCar.cs
客户端：Program.cs

抽象工厂类：AbstractFactory.cs

返回具体产品族的抽象类对象，具体产品类调用

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namesace AbstractFactory
{
    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class AbstractFactorys
    {
        /// <summary>
        /// 抽象发动机类（具体产品族）
        /// </summary>
        public abstract AbstractEngine CreateEngine();
        /// <summary>
        /// 抽象变速器类（具体产品族）
        /// </summary>
        public abstract AbstractSpeed CreateSpeed();
    }
}
 

抽象发动机类（产品族）：AbstractEngine.cs

不同类型的发动机继承这个抽象发动机类来进行生产。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AbstractFactory
{
    /// <summary>
    /// 生产发动机抽象类
    /// </summary>
    public abstract class AbstractEngine
    {
        /// <summary>
        /// 生产产品的方法
        /// </summary>
        public abstract void vardump();
    }
}

抽象变速器类（产品族）：AbstractSpeed.cs

不同类型的变速器继承这个抽象变速器类来进行生产。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
  
namespace AbstractFactory
{
    /// <summary>
    /// 生产变速器抽象类
    /// </summary>
    public abstract class AbstractSpeed
    {
        /// <summary>
        /// 生产产品的方法
        /// </summary>
        public abstract void vardump();
    }
}

奥迪发动机类（具体产品）：AudiEngine.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
  
namespace AbstractFactory
{
    /// <summary>
    /// 奥迪发动机类（具体）
    /// </summary>
    public class AudiEngine:AbstractEngine
    {
        public override void vardump()
        {
            Console.WriteLine("奥迪发动机生产完毕！");
        }
    }
}

大众发动机类（具体产品）：DasEngine.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
  
namespace AbstractFactory
{
    /// <summary>
    /// 大众发动机类（具体）
    /// </summary>
    public class DasEngine: AbstractEngine
    {
        public override void vardump()
        {
            Console.WriteLine("dazhong发动机生产完毕！");
        }
    }
}

奥迪变速器类（具体产品）：AudiSpeed.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
  
namespace AbstractFactory
{
    /// <summary>
    /// 奥迪变速器类（具体）
    /// </summary>
    public class AudiSpeed:AbstractSpeed
    {
        public override void vardump()
        {
            Console.WriteLine("奥迪变速器生产完毕！");
        }
    }
}

大众变速器类（具体产品）：DasSpeed.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
  
namespace AbstractFactory
{
    /// <summary>
    /// 大众变速器类（具体）
    /// </summary>
    public class DasSpeed:AbstractSpeed
    {
        public override void vardump()
        {
            Console.WriteLine("dazhong变速器生产完毕！");
        }
    }
}

奥迪汽车类：AudiCar.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
  
namespace AbstractFactory
{
    /// <summary>
    /// 奥迪汽车类
    /// </summary>
    public class AudiCar: AbstractFactorys
    {
        public override AbstractEngine CreateEngine()
        {
            return new AudiEngine();
        }
  
        public override AbstractSpeed CreateSpeed()
        {
            return new AudiSpeed();
        }
    }
}

大众汽车类：DasCar.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
  
namespace AbstractFactory
{
    /// <summary>
    /// 大众汽车类
    /// </summary>
    public class DasCar:AbstractFactorys
    {
        /// <summary>
        /// 发动机
        /// </summary>
        /// <returns></returns>
        public override AbstractEngine CreateEngine ()
        {
            return new DasEngine();
        }
  
        /// <summary>
        /// 变速箱
        /// </summary>
        /// <returns></returns>
        public override AbstractSpeed CreateSpeed()
        {
            return new DasSpeed();
        }
    }
}

客户端：Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
  
namespace AbstractFactory
{
    /// <summary>
    /// 客户端
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            AbstractEngine engine = null;
            AbstractSpeed speed = null;
  
            DasCar audi = new DasCar();
            // 实例化一个奥迪发动机类
            engine =  audi.CreateEngine();
            engine.vardump();
            // 实例化一个奥迪变速器类
            speed = audi.CreateSpeed();
            speed.vardump();
  
            Console.WriteLine("大众汽车组装完成！");
            Console.WriteLine("---------------------------------------------------");
  
            AudiCar das = new AudiCar();
            engine = das.CreateEngine();
            engine.vardump();
  
            speed = das.CreateSpeed();
            speed.vardump();
  
            Console.WriteLine("奥迪汽车组装完成！");
            Console.WriteLine("---------------------------------------------------");
  
            Console.ReadKey();
        }
    }
}

最后具体效果如下：

以上就是抽象工厂模式的小例子，下面我们说一下抽象工厂模式的优缺点;

抽象工厂模式优点：

具体产品在应用层代码隔离，无须关系创建细节
当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一产品族中的对象；

抽象工厂模式缺点：

规定了所有可能被创建的产品集合，产品族扩展新的产品困难，需要修改抽象工厂的接口
增加了系统的抽象性和理解难度
增加新的产品等级结构麻烦

举个例子：增加一个轮胎产品族，我们需要增加抽象轮胎类、具体轮胎类，还需要修改抽象工厂类，相对比较麻烦

适用环境：

用户无需关心对象的创建过程，将对象的创建和使用解耦；
产品等级结构稳定，在设计完成之后不会向系统中增加新的产品等级结构或者删除已有的产品等级结构；　　
系统中有多于一个的产品族，而每次只使用其中某一产品族。可以通过配置文件等方式来使用户能够动态改变产品族，也可以很方便的增加新的产品族；

下边对三个工厂模式做一个统一的总结：

简单工厂模式：

简单工厂模式的工厂类随着产品类的增加需要增加额外的代码

工厂方法模式：

工厂方法模式每个具体工厂类只完成单个实例的创建,所以它具有很好的可扩展性
但是在实际应用中，一个工厂不止会创建单一的产品，因为现在的工厂都多元化了，一个工厂创建一系列的产品，这就引入了抽象工厂的概念。

抽象工厂模式：

抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

以上便是抽象工厂模式的理解。

有好的建议，请在下方输入你的评论。

欢迎访问个人博客
https://guanchao.site

欢迎访问小程序：