• 设计模式：抽象工厂模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

    上一篇《工厂方法模式》                                                              下一篇《单例模式》

    简介：

    抽象工厂模式，它是所有形态的工厂模式中最为抽象和最具一般性的一种形态。它用于处理当有多个抽象角色时的情况。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下创建多个产品组中的产品对象。这种模式根据里氏替换原则，任何接受父类型的地方都应当能够接受子类型。实际上，系统所需要的仅仅是类型与这些抽象产品角色相同的一些实例。

    抽象工厂模式的创建步骤如下：
    1、创建抽象工厂类，定义具体工厂的公共接口。
    2、创建抽象产品族类，定义抽象产品的公共接口。
    3、创建抽象产品类（继承抽象产品族类），定义具体产品的公共接口。
    4、创建具体产品类（继承抽象产品类）&定义生产的具体产品。
    5、创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法。
    6、客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例。

    抽象工厂模式的优点，主要包括：
    1、隔离了具体类的生产：使得客户并不需要知道什么被创建，降低了客户端与具体产品的耦合度。
    2、保证同一产品族的使用：当一个产品族中的多个对象被设计成一起工作时，抽象工厂模式能保证客户端始终只使用同一个产品族中的对象。
    3、易于扩展：增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
    4、提供更高层次的抽象：抽象工厂模式能够提供更高层次的抽象，同时也能够更好地管理不同产品族之间的关系，从而使得系统更加灵活和易于扩展。
    5、符合单一职责原则：每个具体工厂只负责创建一组具体产品，不会与其他产品产生耦合。

    抽象工厂模式的缺点，主要包括：
    1、增加新的产品等级结构麻烦：需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这可能会违背开闭原则。
    2、抽象工厂模式需要识别和定义所有的抽象产品类和具体产品类，这会增加系统的复杂性。
    3、在客户端代码中需要显式地指定使用哪个具体工厂，这会增加客户端代码的复杂性。
    4、如果出现异常情况，很难确定是哪一个工厂或者是哪一个产品出现问题，因为它们都是独立的对象。
    5、实现抽象工厂模式需要消耗较多的时间和精力，因为需要分离出抽象工厂类和具体工厂类，并且需要针对每个具体工厂类编写对应的客户端代码。


    示例：

    在实际应用中，工厂的创建和产品的生产可能会更加复杂，并且可能会有更多的具体工厂和产品类。


    一、C#抽象工厂模式

    以下是一个示例，展示了如何在C#中实现抽象工厂模式：

    1. //首先，定义一个接口来表示工厂：
    2. public interface IFactory {  
    3.     Product CreateProduct();  
    4. }
    5. //接下来，实现具体工厂类，它们分别创建具体产品对象：
    6. public class ConcreteFactoryA : IFactory {  
    7.     public Product CreateProduct() {  
    8.         return new ConcreteProductA();  
    9.     }  
    10. }  
    11.   
    12. public class ConcreteFactoryB : IFactory {  
    13.     public Product CreateProduct() {  
    14.         return new ConcreteProductB();  
    15.     }  
    16. }
    17. //然后，定义一个抽象产品接口和具体产品类来实现该接口：
    18. public interface Product {  
    19.     void Use();  
    20. }  
    21.   
    22. public class ConcreteProductA : Product {  
    23.     public void Use() {  
    24.         Console.WriteLine("Using Product A");  
    25.     }  
    26. }  
    27.   
    28. public class ConcreteProductB : Product {  
    29.     public void Use() {  
    30.         Console.WriteLine("Using Product B");  
    31.     }  
    32. }
    33. //最后，编写客户端代码来使用抽象工厂模式创建产品对象：
    34. public class Client {  
    35.     public void UseProduct(IFactory factory) {  
    36.         Product product = factory.CreateProduct();  
    37.         product.Use();  
    38.     }  
    39. }
    40. //在主程序中，可以创建客户端对象并使用不同的工厂对象来创建产品对象：
    41. static void Main() {  
    42.     Client client = new Client();  
    43.     IFactory factoryA = new ConcreteFactoryA();  
    44.     client.UseProduct(factoryA); // Output: Using Product A  
    45.   
    46.     IFactory factoryB = new ConcreteFactoryB();  
    47.     client.UseProduct(factoryB); // Output: Using Product B  
    48. }


    二、java抽象工厂模式模式

    抽象工厂模式通常通过以下方式实现：

    1. //抽象工厂接口：这是一个工厂的抽象接口，它定义了创建对象的方法，但并不实现。
    2. public interface AbstractFactory {  
    3.     ProductA createProductA();  
    4.     ProductB createProductB();  
    5. } 
    6.   
    7. //具体工厂类：这些类实现了抽象工厂接口，并知道如何创建特定类型的对象。
    8. public class ConcreteFactory1 implements AbstractFactory {  
    9.     @Override  
    10.     public ProductA createProductA() {  
    11.         return new ProductA1();  
    12.     }  
    13.   
    14.     @Override  
    15.     public ProductB createProductB() {  
    16.         return new ProductB1();  
    17.     }  
    18. }  
    19.   
    20. public class ConcreteFactory2 implements AbstractFactory {  
    21.     @Override  
    22.     public ProductA createProductA() {  
    23.         return new ProductA2();  
    24.     }  
    25.   
    26.     @Override  
    27.     public ProductB createProductB() {  
    28.         return new ProductB2();  
    29.     }  
    30. }
    31.   
    32. //抽象产品接口：这些接口定义了产品的规范，即产品应具有的通用方法。
    33. public interface ProductA {  
    34.     void use();  
    35. }  
    36.   
    37. public interface ProductB {  
    38.     void use();  
    39. }
    40.  
    41. //具体产品类：这些类实现了抽象产品接口，并提供了具体的实现。
    42. public class ProductA1 implements ProductA {  
    43.     @Override  
    44.     public void use() {  
    45.         System.out.println("Using product A1");  
    46.     }  
    47. }  
    48.   
    49. public class ProductA2 implements ProductA {  
    50.     @Override  
    51.     public void use() {  
    52.         System.out.println("Using product A2");  
    53.     }  
    54. }  
    55.  
    56. //最后，在客户端代码中，我们通常会使用一个“提供者”类（如名称“Provider”）来获取工厂对象，然后使用这些工厂对象来创建产品。这样可以让客户端代码与工厂的具体实现解耦。
    57. public class Client {  
    58.     private AbstractFactory factory;  
    59.   
    60.     public Client(AbstractFactory factory) {  
    61.         this.factory = factory;  
    62.     }  
    63.   
    64.     public void useProducts() {  
    65.         ProductA productA = factory.createProductA();  
    66.         productA.use();  
    67.         ProductB productB = factory.createProductB();  
    68.         productB.use();  
    69.     }  
    70. }
    71. //主程序    
    72. public static void main(String[] args) {  
    73. 	Client client = new Client();  
    74. 	AbstractFactory factory1 = new ConcreteFactory1();  
    75. 	client.UseProduct(factory1); // Output: Using Product A  
    76. 	
    77. 	AbstractFactory factory2 = new ConcreteFactory2();  
    78. 	client.UseProduct(factory2); // Output: Using Product B  
    79. }


    三、javascript抽象工厂模式

    在JavaScript中，抽象工厂模式通常可以通过构造函数和对象字面量的组合来实现。

    1. // 抽象工厂接口  
    2. function AbstractFactory() {  
    3.     this.createProduct = function() {  
    4.         throw new Error("This method is abstract and has to be implemented");  
    5.     };  
    6. }  
    7.   
    8. // 具体工厂类1  
    9. function ConcreteFactory1() {}  
    10. ConcreteFactory1.prototype.createProduct = function() {  
    11.     return new Product1();  
    12. };  
    13.   
    14. // 具体工厂类2  
    15. function ConcreteFactory2() {}  
    16. ConcreteFactory2.prototype.createProduct = function() {  
    17.     return new Product2();  
    18. };  
    19.   
    20. // 产品接口  
    21. function Product() {}  
    22. Product.prototype.use = function() {  
    23.     throw new Error("This is an abstract method and has to be implemented");  
    24. };  
    25.   
    26. // 产品类1  
    27. function Product1() {}  
    28. Product1.prototype = Object.create(Product.prototype);  
    29. Product1.prototype.constructor = Product1;  
    30. Product1.prototype.use = function() {  
    31.     console.log("Using product 1");  
    32. };  
    33.   
    34. // 产品类2  
    35. function Product2() {}  
    36. Product2.prototype = Object.create(Product.prototype);  
    37. Product2.prototype.constructor = Product2;  
    38. Product2.prototype.use = function() {  
    39.     console.log("Using product 2");  
    40. };  
    41.   
    42. // 客户端代码  
    43. function Client() {  
    44.     var factory;  
    45.   
    46.     this.setFactory = function(f) {  
    47.         factory = f;  
    48.     };  
    49.   
    50.     this.useFactory = function() {  
    51.         var product = factory.createProduct();  
    52.         product.use();  
    53.     };  
    54. }  
    55.   
    56. var client = new Client();  
    57. client.setFactory(new ConcreteFactory1());  
    58. client.useFactory(); // Outputs: Using product 1  
    59. client.setFactory(new ConcreteFactory2());  
    60. client.useFactory(); // Outputs: Using product 2

    四、C++抽象工厂模式

    以下是在C++中实现抽象工厂模式：

    1. #include   
    2. #include   
    3.   
    4. // 抽象产品接口  
    5. class Product {  
    6. public:  
    7.     virtual void use() = 0;  
    8. };  
    9.   
    10. // 具体产品类1  
    11. class ProductA : public Product {  
    12. public:  
    13.     void use() {  
    14.         std::cout << "Using Product A" << std::endl;  
    15.     }  
    16. };  
    17.   
    18. // 具体产品类2  
    19. class ProductB : public Product {  
    20. public:  
    21.     void use() {  
    22.         std::cout << "Using Product B" << std::endl;  
    23.     }  
    24. };  
    25.   
    26. // 抽象工厂接口  
    27. class Factory {  
    28. public:  
    29.     virtual Product* createProduct() = 0;  
    30. };  
    31.   
    32. // 具体工厂类1  
    33. class FactoryA : public Factory {  
    34. public:  
    35.     Product* createProduct() {  
    36.         return new ProductA();  
    37.     }  
    38. };  
    39.   
    40. // 具体工厂类2  
    41. class FactoryB : public Factory {  
    42. public:  
    43.     Product* createProduct() {  
    44.         return new ProductB();  
    45.     }  
    46. };  
    47.   
    48. int main() {  
    49.     // 创建抽象工厂对象  
    50.     Factory* factory = nullptr;  
    51.   
    52.     // 创建具体工厂类1的对象，并赋值给抽象工厂对象  
    53.     FactoryA factoryA;  
    54.     factory = &factoryA;  
    55.   
    56.     // 使用抽象工厂对象创建产品对象，并使用产品对象  
    57.     Product* product = factory->createProduct();  
    58.     product->use();  
    59.   
    60.     // 创建具体工厂类2的对象，并赋值给抽象工厂对象  
    61.     FactoryB factoryB;  
    62.     factory = &factoryB;  
    63.   
    64.     // 使用抽象工厂对象创建产品对象，并使用产品对象  
    65.     product = factory->createProduct();  
    66.     product->use();  
    67.   
    68.     return 0;  
    69. }


    五、python抽象工厂模式

    以下是在python中实现抽象工厂模式：

    1. #定义抽象产品接口，抽象产品接口定义了产品对象的通用方法。
    2. class Product:  
    3.     def use(self):  
    4.         raise NotImplementedError("This method is abstract and has to be implemented")
    5. 		
    6. #实现具体产品类
    7. class ProductA(Product):  
    8.     def use(self):  
    9.         print("Using Product A")  
    10.   
    11. class ProductB(Product):  
    12.     def use(self):  
    13.         print("Using Product B")
    14. 		
    15. #定义抽象工厂接口，抽象工厂接口定义了创建产品对象的通用方法。
    16. class Factory:  
    17.     def createProduct(self):  
    18.         raise NotImplementedError("This method is abstract and has to be implemented")
    19.  
    20. #实现具体工厂类，具体工厂类继承抽象工厂接口并实现createProduct方法
    21. class FactoryA(Factory):  
    22.     def createProduct(self):  
    23.         return ProductA()  
    24.   
    25. class FactoryB(Factory):  
    26.     def createProduct(self):  
    27.         return ProductB()
    28.  
    29. #创建客户端代码，客户端代码使用抽象工厂接口创建产品对象并使用它们。
    30. factory = Factory()  # 创建抽象工厂对象  
    31. product = factory.createProduct()  # 使用抽象工厂对象创建产品对象  
    32. product.use()  # 使用产品对象


    六、go抽象工厂模式

    以下是一个示例，展示了如何在go中实现抽象工厂模式：

    1. //定义接口：首先，定义出需要创建对象的接口，这个接口规定了对象的共有方法。
    2. type Product interface {  
    3.  Use()  
    4. }  
    5.   
    6. type ConcreteProductA struct{}  
    7.   
    8. func (p *ConcreteProductA) Use() {  
    9.  fmt.Println("Using Product A")  
    10. }  
    11.   
    12. type ConcreteProductB struct{}  
    13.   
    14. func (p *ConcreteProductB) Use() {  
    15.  fmt.Println("Using Product B")  
    16. }
    17.  
    18. //定义抽象工厂接口：接下来，定义出抽象工厂接口，这个接口规定了创建对象的方法。
    19. type Factory interface {  
    20.  CreateProduct() Product  
    21. }  
    22.   
    23. type ConcreteFactoryA struct{}  
    24.   
    25. func (f *ConcreteFactoryA) CreateProduct() Product {  
    26.  return &ConcreteProductA{}  
    27. }  
    28.   
    29. type ConcreteFactoryB struct{}  
    30.   
    31. func (f *ConcreteFactoryB) CreateProduct() Product {  
    32.  return &ConcreteProductB{}  
    33. }
    34.  
    35. //实现客户端代码：现在可以写客户端代码了，这个代码使用抽象工厂接口来创建产品对象。
    36. func main() {  
    37.  factoryA := &ConcreteFactoryA{}  
    38.  productA := factoryA.CreateProduct()  
    39.  productA.Use() // Output: Using Product A  
    40.   
    41.  factoryB := &ConcreteFactoryB{}  
    42.  productB := factoryB.CreateProduct()  
    43.  productB.Use() // Output: Using Product B  
    44. }


    七、PHP抽象工厂模式

    以下是一个示例，展示了如何在PHP中实现抽象工厂模式：

    1. // 抽象产品接口  
    2. interface Product {  
    3.     public function operation();  
    4. }  
    5.   
    6. // 具体产品类实现抽象接口  
    7. class ConcreteProductA implements Product {  
    8.     public function operation() {  
    9.         echo "Product A operation\n";  
    10.     }  
    11. }  
    12.   
    13. class ConcreteProductB implements Product {  
    14.     public function operation() {  
    15.         echo "Product B operation\n";  
    16.     }  
    17. }  
    18.   
    19. // 抽象工厂接口  
    20. interface Factory {  
    21.     public function createProduct();  
    22. }  
    23.   
    24. // 具体工厂类实现抽象工厂接口，创建具体产品对象  
    25. class ConcreteFactoryA implements Factory {  
    26.     public function createProduct() {  
    27.         return new ConcreteProductA();  
    28.     }  
    29. }  
    30.   
    31. class ConcreteFactoryB implements Factory {  
    32.     public function createProduct() {  
    33.         return new ConcreteProductB();  
    34.     }  
    35. }  
    36.   
    37. // 客户端代码使用抽象工厂对象创建具体产品对象  
    38. class Client {  
    39.     public function useProduct(Factory $factory) {  
    40.         $product = $factory->createProduct();  
    41.         $product->operation();  
    42.     }  
    43. }  
    44.   
    45. // 示例用法  
    46. $client = new Client();  
    47. $factoryA = new ConcreteFactoryA();  
    48. $client->useProduct($factoryA); // Output: Product A operation  
    49.   
    50. $factoryB = new ConcreteFactoryB();  
    51. $client->useProduct($factoryB); // Output: Product B operation

    《完结》

    上一篇《工厂方法模式》​​​​​​​                                                              下一篇《单例模式》

  • 相关阅读:
    MySQL - 在 Windows 上安装 MySQL
    人类的谋算与量子计算
    渗透测试高级技巧（一）：分析验签与前端加密
    【深度学习】torch-张量Tensor
    SpringBoot 玩一玩代码混淆，防止反编译代码泄露！
    ubuntu nginx改时区
    一款免费无限制的AI生成视频工具（不输pika、runway）
    拼多多淘宝，如何控价
    Java开发 - 你不知道的JVM优化详解
    多进程与多线程 - 概述
  • 原文地址：https://blog.csdn.net/yetyrain/article/details/133912429