【23种设计模式】抽象工厂模式（三）

秋凉

前言

在抽象工厂模式开篇之前，我们先思考一个问题，如果我们要设计一套房子，其他的组件暂时不考虑，我们仅仅考虑房顶、地板、窗户、房门进行设计。什么样的风格暂时未知，可能会有很多种类。可以先设计一套古典风格的房子，再设计一套现代风格的房子，再设计一套欧式风格的房子....这么多套房子需要设计，需求不断变化，我们该怎么才能后期的维护和扩展就更有利呢？那当然是减少客户端代码与具体产品类之间的依赖，降低了系统的耦合度，这就是抽象工厂模式的优点之处。
抽象工厂模式定义

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

• 抽象产品类角色（AbstractProduct）：为抽象工厂中相互依赖的每种产品定义抽象接口对象，也可以这样说，有几种产品，就要声明几个抽象角色，每一个抽象产品角色和一种具体的产品相匹配。
  
• 具体产品类（ConcreteProduct）：具体产品类实现了抽象产品类，是针对某个具体产品的实现的类型。
  
• 抽象工厂类角色（Abstract Factory）：定义了创建一组相互依赖的产品对象的接口操作，每种操作和每种产品一一对应。
  
• 具体工厂类角色（ConcreteFactory）：实现抽象类里面的所有抽象接口操作，可以创建某系列具体的产品，这些具体的产品是“抽象产品类角色”的子类。
  

抽象工厂模式代码实现

抽象工厂模式的实现，只需要创建三个类：抽象工厂类，具体风格工厂类和具体产品风格实现类。当然也可以分离成四个类，将设计产品接口从抽象工厂分离出来。以设计欧式风格建筑为例：

• 创建抽象工厂类
  1. /// <summary>
  2.     /// 抽象工厂类，提供创建不同类型房子的接口
  3.     /// </summary>
  4.     public abstract class AbstractFactory
  5.     {
  6.         /// <summary>
  7.         /// 抽象工厂提供创建一系列产品的接口——抽象方法，这里作为例子，只给出了房顶、地板、窗户和房门创建接口
  8.         /// 【1】房顶创建接口
  9.         /// </summary>
  10.         /// <returns></returns>
  11.         public abstract Roof CreateRoof();
  12.         /// <summary>
  13.         /// 【2】地板创建接口
  14.         /// </summary>
  15.         /// <returns></returns>
  16.         public abstract Floor CreateFloor();
  17.         /// <summary>
  18.         /// 【3】窗户创建接口
  19.         /// </summary>
  20.         /// <returns></returns>
  21.         public abstract Window CreateWindow();
  22.         /// <summary>
  23.         /// 【4】房门创建接口
  24.         /// </summary>
  25.         /// <returns></returns>
  26.         public abstract Door CreateDoor();
  27.     }
  28.    
  29.     #region 可以分离出来到单独Class文件的产品接口
  30.     /// <summary>
  31.     /// 房顶抽象类，子类的房顶必须继承该类
  32.     /// </summary>
  33.     public abstract class Roof
  34.     {
  35.         /// <summary>
  36.         /// 创建房顶
  37.         /// </summary>
  38.         public abstract void Create();
  39.     }
  41.     /// <summary>
  42.     /// 地板抽象类，子类的地板必须继承该类
  43.     /// </summary>
  44.     public abstract class Floor
  45.     {
  46.         /// <summary>
  47.         /// 创建地板
  48.         /// </summary>
  49.         public abstract void Create();
  50.     }
  52.     /// <summary>
  53.     /// 窗户抽象类，子类的窗户必须继承该类
  54.     /// </summary>
  55.     public abstract class Window
  56.     {
  57.         /// <summary>
  58.         /// 创建窗户
  59.         /// </summary>
  60.         public abstract void Create();
  61.     }
  63.     /// <summary>
  64.     /// 房门抽象类，子类的房门必须继承该类
  65.     /// </summary>
  66.     public abstract class Door
  67.     {
  68.         /// <summary>
  69.         /// 创建房门
  70.         /// </summary>
  71.         public abstract void Create();
  72.     }
  74.     #endregion

  复制代码
• 创建欧式风格工厂
  1. /// <summary>
  2.     /// 欧式风格房子的工厂，负责创建欧式风格的房子
  3.     /// </summary>
  4.     public class EuropeanFactory : AbstractFactory
  5.     {
  6.         // 制作欧式房顶
  7.         public override Roof CreateRoof()
  8.         {
  9.             return new EuropeanRoof();
  10.         }
  12.         // 制作欧式地板
  13.         public override Floor CreateFloor()
  14.         {
  15.             return new EuropeanFloor();
  16.         }
  18.         // 制作欧式窗户
  19.         public override Window CreateWindow()
  20.         {
  21.             return new EuropeanWindow();
  22.         }
  24.         // 制作欧式房门
  25.         public override Door CreateDoor()
  26.         {
  27.             return new EuropeanDoor();
  28.         }
  29.     }

  复制代码
• 创建欧式风格实现
  1. /// <summary>
  2.     /// European 欧式风格建筑
  3.     /// </summary>
  4.     public class European
  5.     {
  6.         /// <summary>
  7.         /// 欧式地板类
  8.         /// </summary>
  9.         public class EuropeanFloor : Floor
  10.         {
  11.             public override void Create()
  12.             {
  13.                 Console.WriteLine("创建欧式的地板");
  14.             }
  15.         }
  18.         /// <summary>
  19.         /// 欧式的房顶
  20.         /// </summary>
  21.         public class EuropeanRoof : Roof
  22.         {
  23.             public override void Create()
  24.             {
  25.                 Console.WriteLine("创建欧式的房顶");
  26.             }
  27.         }
  30.         /// <summary>
  31.         ///欧式的窗户
  32.         /// </summary>
  33.         public class EuropeanWindow : Window
  34.         {
  35.             public override void Create()
  36.             {
  37.                 Console.WriteLine("创建欧式的窗户");
  38.             }
  39.         }
  42.         /// <summary>
  43.         /// 欧式的房门
  44.         /// </summary>
  45.         public class EuropeanDoor : Door
  46.         {
  47.             public override void Create()
  48.             {
  49.                 Console.WriteLine("创建欧式的房门");
  50.             }
  51.         }
  53.     }

  复制代码
• 欧式风格调用
  1. public void RunTest()
  2.         {
  3.             // 欧式风格的房子
  4.             Console.WriteLine("开始设计欧式风格房子！");
  5.             AbstractFactory europeanFactory = new EuropeanFactory();
  6.             europeanFactory.CreateRoof().Create();
  7.             europeanFactory.CreateFloor().Create();
  8.             europeanFactory.CreateWindow().Create();
  9.             europeanFactory.CreateDoor().Create();
  10.         }

  复制代码

如果新需求设计新的风格房子，现代风格建筑，只需要创建对应的具体实现工厂和具体产品分风格设计实现。

• 创建现代风格工厂
  1. /// <summary>
  2.     /// 现在风格房子的工厂，负责创建现代风格的房子
  3.     /// </summary>
  4.     public class ModernizationFactory : AbstractFactory
  5.     {
  6.         // 制作现代房顶
  7.         public override Roof CreateRoof()
  8.         {
  9.             return new ModernizationRoof();
  10.         }
  12.         // 制作现代地板
  13.         public override Floor CreateFloor()
  14.         {
  15.             return new ModernizationFloor();
  16.         }
  18.         // 制作现代窗户
  19.         public override Window CreateWindow()
  20.         {
  21.             return new ModernizationWindow();
  22.         }
  24.         // 制作现代房门
  25.         public override Door CreateDoor()
  26.         {
  27.             return new ModernizationDoor();
  28.         }
  29.     }

  复制代码
• 创建现代风格实现
  1.   /// <summary>
  2.     /// Modernization 现代风格建筑
  3.     /// </summary>
  4.     public class Modernization
  5.     {
  7.         /// <summary>
  8.         /// 现代的房顶
  9.         /// </summary>
  10.         public class ModernizationRoof : Roof
  11.         {
  12.             public override void Create()
  13.             {
  14.                 Console.WriteLine("创建现代的房顶");
  15.             }
  16.         }
  18.         /// <summary>
  19.         /// 现代的地板
  20.         /// </summary>
  21.         public class ModernizationFloor : Floor
  22.         {
  23.             public override void Create()
  24.             {
  25.                 Console.WriteLine("创建现代的地板");
  26.             }
  27.         }
  29.         /// <summary>
  30.         /// 现代的窗户
  31.         /// </summary>
  32.         public class ModernizationWindow : Window
  33.         {
  34.             public override void Create()
  35.             {
  36.                 Console.WriteLine("创建现代的窗户");
  37.             }
  38.         }
  40.         /// <summary>
  41.         /// 现代的房门
  42.         /// </summary>
  43.         public class ModernizationDoor : Door
  44.         {
  45.             public override void Create()
  46.             {
  47.                 Console.WriteLine("创建现代的房门");
  48.             }
  49.         }
  51.     }

  复制代码
• 现代风格调用
  1. public void RunTest()
  2.         {
  3.             // 欧式风格的房子
  4.             Console.WriteLine("开始设计欧式风格房子！");
  5.             AbstractFactory europeanFactory = new EuropeanFactory();
  6.             europeanFactory.CreateRoof().Create();
  7.             europeanFactory.CreateFloor().Create();
  8.             europeanFactory.CreateWindow().Create();
  9.             europeanFactory.CreateDoor().Create();
  12.             //现代风格的房子
  13.             Console.WriteLine("开始设计现代风格的房子！");
  14.             AbstractFactory modernizationFactory = new ModernizationFactory();
  15.             modernizationFactory.CreateRoof().Create();
  16.             modernizationFactory.CreateFloor().Create();
  17.             modernizationFactory.CreateWindow().Create();
  18.             modernizationFactory.CreateDoor().Create();
  19.         }

  复制代码

抽象工厂模式的优缺点

优点：

【抽象工厂模式】将系列产品的创建工作延迟到具体工厂的子类中，我们声明工厂类变量的时候是使用的抽象类型，同理，我们使用产品类型也是抽象类型，这样做就尽可能的可以减少客户端代码与具体产品类之间的依赖，从而降低了系统的耦合度。耦合度降低了，对于后期的维护和扩展就更有利，这也就是【抽象工厂模式】的优点所在。
缺点：

【抽象工厂模式】很难支持增加新产品的变化，这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类以及所有子类的改变，这样也就违背了“开放—封闭”原则。

来源:https://www.cnblogs.com/wml-it/archive/2023/08/29/17664187.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！