1.1 工厂方法 Virtual Constructor、Factory Method

妖狐艹你老母 2022-12-20 06:10 94阅读 0赞

**专业描述** 工厂方法模式在父类中提供一个创建对象的方法， 允许子类决定实例化对象的类型。

**工厂方法模式结构**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjMxMzc5_size_16_color_FFFFFF_t_70_pic_center]

1.  **产品** （Product） 将会对接口进行声明。 对于所有由创建者及其子类构建的对象， 这些接口都是通用的。
2.  **具体产品** （Concrete Products） 是产品接口的不同实现。
3.  **创建者** （Creator） 类声明返回产品对象的工厂方法。 该方法的返回对象类型必须与产品接口相匹配。

*  你可以将工厂方法声明为抽象方法， 强制要求每个子类以不同方式实现该方法。 或者， 你也可以在基础工厂方法中返回默认产品类型。
 *  注意， 尽管它的名字是创建者， 但他最主要的职责并**不是**创建产品。 一般来说， 创建者类包含一些与产品相关的核心业务逻辑。 工厂方法将这些逻辑处理从具体产品类中分离出来。 打个比方， 大型软件开发公司拥有程序员培训部门。 但是， 这些公司的主要工作还是编写代码， 而非生产程序员。

1.  **具体创建者** （Concrete Creators） 将会重写基础工厂方法， 使其返回不同类型的产品。

*  注意， 并不一定每次调用工厂方法都会**创建**新的实例。 工厂方法也可以返回缓存、 对象池或其他来源的已有对象。

实现方法：

1.  让所有产品都遵循同一接口。 该接口必须声明对所有产品都有意义的方法。
2.  在创建类中添加一个空的工厂方法。 该方法的返回类型必须遵循通用的产品接口。
3.  在创建者代码中找到对于产品构造函数的所有引用。 将它们依次替换为对于工厂方法的调用， 同时将创建产品的代码移入工厂方法。 你可能需要在工厂方法中添加临时参数来控制返回的产品类型。
4.  现在， 为工厂方法中的每种产品编写一个创建者子类， 然后在子类中重写工厂方法， 并将基本方法中的相关创建代码移动到工厂方法中。
5.  如果应用中的产品类型太多， 那么为每个产品创建子类并无太大必要， 这时你也可以在子类中复用基类中的控制参数。

> 例如， 设想你有以下一些层次结构的类。 基类 邮件及其子类 航空邮件和 陆路邮件 ；  运输及其子类 飞机, 卡车和 火车 。  航空邮件仅使用 飞机对象， 而 陆路邮件则会同时使用 卡车和 火车对象。 你可以编写一个新的子类 （例如 火车邮件 ） 来处理这两种情况， 但是还有其他可选的方案。 客户端代码可以给 陆路邮件类传递一个参数， 用于控制其希望获得的产品。

1.  如果代码经过上述移动后， 基础工厂方法中已经没有任何代码， 你可以将其转变为抽象类。 如果基础工厂方法中还有其他语句， 你可以将其设置为该方法的默认行为。

C++算法概念示例：

/** * The Product interface declares the operations that all concrete products must * implement. */
    
    class Product { 
     public:
      virtual ~Product() { }
      virtual std::string Operation() const = 0;
    };
    
    /** * Concrete Products provide various implementations of the Product interface. */
    class ConcreteProduct1 : public Product { 
     public:
      std::string Operation() const override { 
        return "{Result of the ConcreteProduct1}";
      }
    };
    class ConcreteProduct2 : public Product { 
     public:
      std::string Operation() const override { 
        return "{Result of the ConcreteProduct2}";
      }
    };
    
    /** * The Creator class declares the factory method that is supposed to return an * object of a Product class. The Creator's subclasses usually provide the * implementation of this method. */
    
    class Creator { 
      /** * Note that the Creator may also provide some default implementation of the * factory method. */
     public:
      virtual ~Creator(){ };
      virtual Product* FactoryMethod() const = 0;
      /** * Also note that, despite its name, the Creator's primary responsibility is * not creating products. Usually, it contains some core business logic that * relies on Product objects, returned by the factory method. Subclasses can * indirectly change that business logic by overriding the factory method and * returning a different type of product from it. */
    
      std::string SomeOperation() const { 
        // Call the factory method to create a Product object.
        Product* product = this->FactoryMethod();
        // Now, use the product.
        std::string result = "Creator: The same creator's code has just worked with " + product->Operation();
        delete product;
        return result;
      }
    };
    
    /** * Concrete Creators override the factory method in order to change the * resulting product's type. */
    class ConcreteCreator1 : public Creator { 
      /** * Note that the signature of the method still uses the abstract product type, * even though the concrete product is actually returned from the method. This * way the Creator can stay independent of concrete product classes. */
     public:
      Product* FactoryMethod() const override { 
        return new ConcreteProduct1();
      }
    };
    
    class ConcreteCreator2 : public Creator { 
     public:
      Product* FactoryMethod() const override { 
        return new ConcreteProduct2();
      }
    };
    
    /** * The client code works with an instance of a concrete creator, albeit through * its base interface. As long as the client keeps working with the creator via * the base interface, you can pass it any creator's subclass. */
    void ClientCode(const Creator& creator) { 
      // ...
      std::cout << "Client: I'm not aware of the creator's class, but it still works.\n"
                << creator.SomeOperation() << std::endl;
      // ...
    }
    
    /** * The Application picks a creator's type depending on the configuration or * environment. */
    
    int main() { 
      std::cout << "App: Launched with the ConcreteCreator1.\n";
      Creator* creator = new ConcreteCreator1();
      ClientCode(*creator);
      std::cout << std::endl;
      std::cout << "App: Launched with the ConcreteCreator2.\n";
      Creator* creator2 = new ConcreteCreator2();
      ClientCode(*creator2);
    
      delete creator;
      delete creator2;
      return 0;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjMxMzc5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/dfd3369162174ce49ffcc5818ec08753.png