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

    上一篇《简单工厂模式》                                                    下一篇《抽象工厂模式》

    简介：

    工厂方法模式，它是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
    它定义了一个用于创建对象的工厂接口，让子类决定实例化哪个类。在工厂方法模式中，父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。这种模式将类实例化操作延迟到子类中完成，即由子类来决定究竟应该实例化哪个类。

    工厂方法模式的创建步骤如下：
    1、创建抽象工厂类，定义具体工厂的公共接口。
    2、创建抽象产品类，定义具体产品的公共接口。
    3、创建具体产品类，继承抽象产品类并定义具体产品的生产。
    4、创建具体工厂类，继承抽象工厂类并定义创建对应具体产品实例的方法。
    5、外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例。

    工厂方法模式的优点，主要包括：
    1、增加新的产品类时无需修改现有系统：当需要增加一个新的产品时，只需要创建一个新的具体工厂和具体产品类，符合“开放-封闭”原则，增加了系统的灵活性和可扩展性。
    2、封装了产品对象的创建细节：客户端只需要使用具体工厂类创建产品对象，无需关心对象是如何被创建的，这样就可以将产品对象的创建细节封装在具体工厂类中。
    3、系统具有良好的灵活性和可扩展性：通过使用工厂方法模式，可以在不改变现有客户端代码的情况下，增加或修改产品类和工厂类，具有较强的灵活性。

    工厂方法模式的缺点，主要包括：
    1、增加额外的编写工作量：在增加新产品时，需要编写新的具体产品类和对应的具体工厂类，增加了系统的复杂度，需要更多的类需要编译和运行，给系统带来一些额外的开销。
    2、需要考虑系统的抽象性和理解难度：为了增加系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。

    示例

    一、C#工厂方法模式

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

    1. // 产品的抽象类  
    2. public abstract class Product  
    3. {  
    4.     public abstract void Use();  
    5. }  
    6.   
    7. // 具体产品类1  
    8. public class ConcreteProduct1 : Product  
    9. {  
    10.     public override void Use()  
    11.     {  
    12.         Console.WriteLine("使用具体产品1");  
    13.     }  
    14. }  
    15.   
    16. // 具体产品类2  
    17. public class ConcreteProduct2 : Product  
    18. {  
    19.     public override void Use()  
    20.     {  
    21.         Console.WriteLine("使用具体产品2");  
    22.     }  
    23. }  
    24.   
    25. // 工厂的抽象类  
    26. public abstract class Creator  
    27. {  
    28.     // 工厂方法，由子类实现具体的创建逻辑  
    29.     public abstract Product CreateProduct();  
    30. }  
    31.   
    32. // 具体工厂类1  
    33. public class ConcreteCreator1 : Creator  
    34. {  
    35.     public override Product CreateProduct()  
    36.     {  
    37.         return new ConcreteProduct1();  
    38.     }  
    39. }  
    40.   
    41. // 具体工厂类2  
    42. public class ConcreteCreator2 : Creator  
    43. {  
    44.     public override Product CreateProduct()  
    45.     {  
    46.         return new ConcreteProduct2();  
    47.     }  
    48. }  
    49.   
    50. class Program  
    51. {  
    52.     static void Main(string[] args)  
    53.     {  
    54.         Creator creator1 = new ConcreteCreator1(); 
    55.         Product product1 = creator1.CreateProduct();   
    56.         product1.Use();  
    57.         
    58.         Creator creator2 = new ConcreteCreator2  
    59.         Product product2 = creator2.CreateProduct(); 
    60.         product2.Use();  
    61.     }  
    62. }

    二、java工厂方法模式

    以下是一个示例，展示了如何在Java中实现工厂方法模式：

    1. // 抽象产品类  
    2. public abstract class Product {  
    3.     public abstract void use();  
    4. }  
    5.   
    6. // 具体产品类1  
    7. public class ConcreteProduct1 extends Product {  
    8.     @Override  
    9.     public void use() {  
    10.         System.out.println("使用具体产品1");  
    11.     }  
    12. }  
    13.   
    14. // 具体产品类2  
    15. public class ConcreteProduct2 extends Product {  
    16.     @Override  
    17.     public void use() {  
    18.         System.out.println("使用具体产品2");  
    19.     }  
    20. }  
    21.   
    22. // 抽象工厂类  
    23. public abstract class Factory {  
    24.     // 工厂方法，由子类实现具体的创建逻辑  
    25.     public abstract Product createProduct();  
    26. }  
    27.   
    28. // 具体工厂类1  
    29. public class ConcreteFactory1 extends Factory {  
    30.     @Override  
    31.     public Product createProduct() {  
    32.         return new ConcreteProduct1();  
    33.     }  
    34. }  
    35.   
    36. // 具体工厂类2  
    37. public class ConcreteFactory2 extends Factory {  
    38.     @Override  
    39.     public Product createProduct() {  
    40.         return new ConcreteProduct2();  
    41.     }  
    42. }  
    43.   
    44. // Client代码  
    45. public class Client {  
    46.     public static void main(String[] args) {  
    47.         Factory factory = new ConcreteFactory1(); // 可以根据实际需要更换为ConcreteFactory2  
    48.         Product product = factory.createProduct();  
    49.         product.use();  
    50.     }  
    51. }


    三、javascript工厂方法模式

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

    1. // 抽象产品类  
    2. class Product {  
    3.   // 抽象方法  
    4.   use() {  
    5.     throw new Error('Use abstract method "use"');  
    6.   }  
    7. }  
    8.   
    9. // 具体产品类1  
    10. class ConcreteProduct1 extends Product {  
    11.   use() {  
    12.     console.log('使用具体产品1');  
    13.   }  
    14. }  
    15.   
    16. // 具体产品类2  
    17. class ConcreteProduct2 extends Product {  
    18.   use() {  
    19.     console.log('使用具体产品2');  
    20.   }  
    21. }  
    22.   
    23. // 抽象工厂类  
    24. class Factory {  
    25.   // 工厂方法，由子类实现具体的创建逻辑  
    26.   createProduct() {  
    27.     throw new Error('Use abstract method "createProduct"');  
    28.   }  
    29. }  
    30.   
    31. // 具体工厂类1  
    32. class ConcreteFactory1 extends Factory {  
    33.   createProduct() {  
    34.     return new ConcreteProduct1();  
    35.   }  
    36. }  
    37.   
    38. // 具体工厂类2  
    39. class ConcreteFactory2 extends Factory {  
    40.   createProduct() {  
    41.     return new ConcreteProduct2();  
    42.   }  
    43. }  
    44.   
    45. // Client代码  
    46. class Client {  
    47.   constructor(factory) {  
    48.     this.factory = factory;  
    49.   }  
    50.   
    51.   useProduct() {  
    52.     let product = this.factory.createProduct();  
    53.     product.use();  
    54.   }  
    55. }  
    56.   
    57. // 使用Client类和ConcreteFactory1实例化一个新的Client对象并使用产品  
    58. let client1 = new Client(new ConcreteFactory1());  
    59. client1.useProduct();

    四、C++工厂方法模式

    以下是在C++中实现工厂方法模式：

    1. //定义一个抽象产品类，它包含产品对象的公共接口。
    2. class Product {  
    3. public:  
    4.   virtual void use() = 0; // 纯虚函数，具体实现由子类来决定  
    5. };
    6. //创建具体产品类，它们扩展了抽象产品类并实现了产品的具体行为。
    7. class ConcreteProduct1 : public Product {  
    8. public:  
    9.   void use() override {  
    10.     // 具体实现逻辑  
    11.     std::cout << "使用具体产品1" << std::endl;  
    12.   }  
    13. };  
    14.   
    15. class ConcreteProduct2 : public Product {  
    16. public:  
    17.   void use() override {  
    18.     // 具体实现逻辑  
    19.     std::cout << "使用具体产品2" << std::endl;  
    20.   }  
    21. };
    22. //定义一个抽象工厂类，它包含一个工厂方法用于创建产品对象。这个方法是纯虚函数，具体实现由子类来决定。
    23. class Factory {  
    24. public:  
    25.   virtual Product* createProduct() = 0; // 纯虚函数，具体实现由子类来决定  
    26. };
    27. //创建具体工厂类，它们扩展了抽象工厂类并实现了工厂方法的特定实现，以创建特定类型的产品对象。
    28. class ConcreteFactory1 : public Factory {  
    29. public:  
    30.   Product* createProduct() override {  
    31.     return new ConcreteProduct1();  
    32.   }  
    33. };  
    34.   
    35. class ConcreteFactory2 : public Factory {  
    36. public:  
    37.   Product* createProduct() override {  
    38.     return new ConcreteProduct2();  
    39.   }  
    40. };
    41. //最后，在客户端代码中使用工厂方法模式来创建产品对象。客户端通过调用工厂对象的 createProduct 方法来创建产品对象，而不需要直接了解如何创建这些对象。这样可以提高客户端代码的灵活性和可维护性。
    42. int main() {  
    43.   Factory* factory = new ConcreteFactory1(); // 创建具体工厂对象  
    44.   Product* product = factory->createProduct(); // 创建具体产品对象  
    45.   product->use(); // 使用具体产品对象  
    46.   
    47.   delete factory; // 释放工厂对象内存  
    48.   delete product; // 释放产品对象内存  
    49.   
    50.   return 0;  
    51. }

    五、python工厂方法模式

    以下是在python中实现工厂方法模式：

    1. from abc import ABCMeta, abstractmethod  
    2.   
    3. # 抽象产品类  
    4. class Product(metaclass=ABCMeta):  
    5.     @abstractmethod  
    6.     def operation(self):  
    7.         pass  
    8.   
    9. # 具体产品类1  
    10. class ConcreteProduct1(Product):  
    11.     def operation(self):  
    12.         print("具体产品1被使用了")  
    13.   
    14. # 具体产品类2  
    15. class ConcreteProduct2(Product):  
    16.     def operation(self):  
    17.         print("具体产品2被使用了")  
    18.   
    19. # 抽象工厂类  
    20. class Factory(metaclass=ABCMeta):  
    21.     @abstractmethod  
    22.     def create_product(self):  
    23.         pass  
    24.   
    25. # 具体工厂类1  
    26. class ConcreteFactory1(Factory):  
    27.     def create_product(self):  
    28.         return ConcreteProduct1()  
    29.   
    30. # 具体工厂类2  
    31. class ConcreteFactory2(Factory):  
    32.     def create_product(self):  
    33.         return ConcreteProduct2()  
    34.   
    35. # Client代码  
    36. if __name__ == "__main__":  
    37.     factory1 = ConcreteFactory1()  
    38.     product1 = factory1.create_product()  
    39.     product1.operation()  
    40.   
    41.     factory2 = ConcreteFactory2()  
    42.     product2 = factory2.create_product()  
    43.     product2.operation()

        

    六、go工厂方法模式

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

    1. //首先定义一个产品接口，该接口定义了产品的通用方法：
    2. type Product interface {  
    3.  Use()  
    4. }
    5. //然后，定义两个具体产品结构体，并实现Product接口的方法：
    6. type ConcreteProduct1 struct{}  
    7.   
    8. func (p *ConcreteProduct1) Use() {  
    9.  fmt.Println("使用具体产品1")  
    10. }  
    11.   
    12. type ConcreteProduct2 struct{}  
    13.   
    14. func (p *ConcreteProduct2) Use() {  
    15.  fmt.Println("使用具体产品2")  
    16. }
    17. //接下来，定义一个工厂接口，该接口定义了一个创建产品的 方法：
    18. type Factory interface {  
    19.  CreateProduct() Product  
    20. }
    21. //然后，定义两个具体工厂结构体，并实现Factory接口的方法：
    22. type ConcreteFactory1 struct{}  
    23.   
    24. func (f *ConcreteFactory1) CreateProduct() Product {  
    25.  return &ConcreteProduct1{}  
    26. }  
    27.   
    28. type ConcreteFactory2 struct{}  
    29.   
    30. func (f *ConcreteFactory2) CreateProduct() Product {  
    31.  return &ConcreteProduct2{}  
    32. }
    33. //最后，在客户端代码中，根据需要选择具体的工厂结构体实例化，然后使用该工厂结构体创建并使用产品：
    34. func main() {  
    35.  factory1 := &ConcreteFactory1{}  
    36.  product1 := factory1.CreateProduct()  
    37.  product1.Use()  
    38.   
    39.  factory2 := &ConcreteFactory2{}  
    40.  product2 := factory2.CreateProduct()  
    41.  product2.Use()  
    42. }

    七、PHP工厂方法模式

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

    1. //定义一个抽象产品接口（Abstract Product）：
    2. interface Product {  
    3.     public function operation();  
    4. }
    5. //创建具体产品类实现抽象产品接口：
    6. class ConcreteProduct1 implements Product {  
    7.     public function operation() {  
    8.         echo "具体产品1被使用了";  
    9.     }  
    10. }  
    11.   
    12. class ConcreteProduct2 implements Product {  
    13.     public function operation() {  
    14.         echo "具体产品2被使用了";  
    15.     }  
    16. }
    17. //定义一个抽象工厂类：
    18. abstract class Creator {  
    19.     abstract public function factoryMethod(): Product;  
    20. }
    21. //创建具体工厂类继承抽象工厂类：
    22. class ConcreteCreator1 extends Creator {  
    23.     public function factoryMethod() {  
    24.         return new ConcreteProduct1();  
    25.     }  
    26. }  
    27.   
    28. class ConcreteCreator2 extends Creator {  
    29.     public function factoryMethod() {  
    30.         return new ConcreteProduct2();  
    31.     }  
    32. }
    33. //在客户端代码中，根据需要选择具体的工厂类实例化，并使用该工厂类创建并使用产品：
    34. $creator1 = new ConcreteCreator1();  
    35. $product1 = $creator1->factoryMethod();  
    36. $product1->operation(); // 输出：具体产品1被使用了  
    37.   
    38. $creator2 = new ConcreteCreator2();  
    39. $product2 = $creator2->factoryMethod();  
    40. $product2->operation(); // 输出：具体产品2被使用了

    《完结》

    上一篇《简单工厂模式》 ​​​​​​​                                                    下一篇《抽象工厂模式》

  • 相关阅读:
    Yarn 配置管理
    CH34X系列与CH91XX系列等USB转串口方案选型对比
    Git常见的面试题
    Vim编辑器常用操作手册
    【python笔记】第八节 函数基础
    MATLAB基础应用精讲-【数模应用】事后多重比较
    状态定义与深度优先搜索、广度优先搜索
    实现顺序表
    javaweb唐院寻人表白系统计算机毕业设计MyBatis+系统+LW文档+源码+调试部署
    基于SpringBoot的在线拍卖系统
  • 原文地址：https://blog.csdn.net/yetyrain/article/details/133897048