重温设计模式 --- 抽象工厂模式

引言

抽象工厂模式一种创建型设计模式，它提供了一种方式来封装一组具有相同主题的工厂，而不必指定它们具体的类。这样，客户端代码就可以使用抽象工厂来创建一组相关的对象，而不必关心实际创建的具体类。
抽象工厂模式有以下几个主要角色：

• 抽象工厂（AbstractFactory）：声明用于创建抽象产品的操作的接口。
  
• 工厂实现（ConcreteFactory）：实现创建具体产品对象的操作。
  
• 抽象产品（AbstractProduct）：声明产品对象类型的接口。
  
• 产品实现（Product）：定义由相应的具体工厂创建的产品对象，实现AbstractProduct接口。
  

下面使用C#实现抽象工厂模式:
抽象工厂

定义一个抽象工厂接口，其中包含了创建不同产品的方法：

1. public interface IAbstractFactory
2. {
3.     IProductA CreateProductA();
4.     IProductB CreateProductB();
5. }

复制代码

工厂实现

定义具体的工厂类，实现抽象工厂接口：

1. public class ConcreteFactory1 : IAbstractFactory
2. {
3.     public IProductA CreateProductA()
4.     {
5.         return new ConcreteProductA1();
6.     }
8.     public IProductB CreateProductB()
9.     {
10.         return new ConcreteProductB1();
11.     }
12. }
14. public class ConcreteFactory2 : IAbstractFactory
15. {
16.     public IProductA CreateProductA()
17.     {
18.         return new ConcreteProductA2();
19.     }
21.     public IProductB CreateProductB()
22.     {
23.         return new ConcreteProductB2();
24.     }
25. }

复制代码

在上述示例中，我们定义了两个具体工厂类：ConcreteFactory1和ConcreteFactory2。这两个工厂类都实现了IAbstractFactory接口，并且分别提供了不同的产品实现。
抽象产品

1. public interface IProductA
2. {
3.     string GetName();
4. }

复制代码

产品实现

1. public class ConcreteProductA1 : IProductA
2. {
3.     public string GetName()
4.     {
5.         return "ProductA1";
6.     }
7. }
9. public class ConcreteProductA2 : IProductA
10. {
11.     public string GetName()
12.     {
13.         return "ProductA2";
14.     }
15. }
17. public interface IProductB
18. {
19.     string GetName();
20. }
22. public class ConcreteProductB1 : IProductB
23. {
24.     public string GetName()
25.     {
26.         return "ProductB1";
27.     }
28. }
30. public class ConcreteProductB2 : IProductB
31. {
32.     public string GetName()
33.     {
34.         return "ProductB2";
35.     }
36. }

复制代码

下面，我们可以使用抽象工厂来创建一组相关的对象：

1. public class Client
2. {
3.     private IAbstractFactory factory;
5.     public Client(IAbstractFactory factory)
6.     {
7.         this.factory = factory;
8.     }
10.     public void Run()
11.     {
12.         var productA = factory.CreateProductA();
13.         var productB = factory.CreateProductB();
15.         Console.WriteLine(productA.GetName());
16.         Console.WriteLine(productB.GetName());
17.     }
18. }
20. static void Main(string[] args)
21. {
22.     var client1 = new Client(new ConcreteFactory1());
23.     client1.Run();
25.     var client2 = new Client(new ConcreteFactory2());
26.     client2.Run();
27. }

复制代码

输出：

1. ProductA1
2. ProductB1
4. ProductA2
5. ProductB2

复制代码

总结

上面的示例中，我们使用抽象工厂模式来创建了一组相关的对象，但是需要注意的是，它适用于创建一组相关的产品对象，但是当产品族的变化引起整个工厂等级结构的变化时，抽象工厂模式就不适用了。
此外，抽象工厂模式还存在一些缺点，例如：

• 新增产品会导致工厂接口的扩展。如果需要新增产品，就需要修改所有的工厂类，这会带来一些不必要的麻烦。
  
• 可能会导致类层次结构的复杂度增加。如果有多个产品族，就需要定义多个工厂接口，这会增加类层次结构的复杂度。
  

因此，在使用抽象工厂模式时，需要根据具体情况进行权衡和选择。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！