设计模式：工厂模式(Factory Method)---将实例的生成交给子类

落日映苍穹つ 2022-09-05 01:45 128阅读 0赞

# 工厂模式 #

*  在[Template Method][]模式中，我们在父类中规定处理的流程，在子类中实现具体的处理
 *  工厂模式：**提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类**

# 实现 #

## 实例1：制造身份证 ##

*  Product类和Factory类，组成了生成实例的框架
 *  IDCard类和IDcardFactory类负责实际的加工处理  
    ![在这里插入图片描述][4739cd77320e44c1aa8d5d938832f8ca.png]  
    ![在这里插入图片描述][38bd34cd85fc4be3a29408374f295c9f.png]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]

### Product类 ###

Product是用来表示产品的类，在该类中仅声明了use抽象方法。use方法的实现被交给了Product的子类负责

在这个框架中，定义了产品是“任意的可以use的”东西

class Product {
        
    public:
        virtual ~Product() {
         }
        virtual void use() = 0;
    };

### Factory类 ###

*  Factory类里，使用了template method模式。
 *  该类还声明了用于“声明产品”的CreateProduct抽象方法和用于“注册 产品”的registerProduct抽象方法。
 *  “生成产品”和“注册产品”的具体处理则交给了Factory类的子类负责。

class Factory {
        
    public:
        Product * create(const std::string& owner)  {
        
            Product *p = CreateProduct(owner);
            registerProduct(p);
            return p;
        }
    
    
        virtual ~Factory() = default;
    
        virtual Product* CreateProduct(const std::string& owner) = 0;
    
    protected:
        Factory() = default;
    
        virtual void registerProduct(Product *product) = 0 ;
    };

### IDCard类 ###

上面的两个类定义了框架，接下来我们把关注点转移到负责加工处理的这一边。

IDCard实现了“实际产品”是什么样，必须实现use方法

class IDCard :public Product {
        
    private:
        std::string owner_;
    public:
        explicit IDCard(const std::string& owner) : owner_(owner){
        
            std::cout << "create [" << owner << "]'s card" << std::endl;
        }
        void use() {
        
            std::cout << "use  [" << owner_ << "]'s card" << std::endl;
        }
    
        const char *getOwner(){
        
            return owner_.c_str();
        }
        ~IDCard() override = default;
    };

### IDCardFactory类 ###

class IDCardFactory :public Factory {
        
    private:
        std::list<std::string> owners;
    public:
        IDCardFactory() {
        
            std::cout << "IDCardFactory..." << std::endl;
        }
    
        ~IDCardFactory() {
        
    
        }
    
    private:
        Product* CreateProduct(const std::string& owner) {
        
            return new IDCard(owner);
        }
    
        void registerProduct(Product *product){
        
            IDCard *idCard = (IDCard*)product;
            owners.emplace_back(idCard->getOwner());
        }
    };

### 测试 ###

int main() {
        
        Factory *factory = new IDCardFactory();
        Product *product = factory->CreateProduct("aaa");
        product->use();
    
        Product *product1 = factory->CreateProduct("bbb");
        product1->use();
    
    
        delete factory;
        delete product;
        delete product1;
        return 0;
    }

## 实现2： ##

#include <iostream>
    
    // Product
    
    class Product {
        
    public:
        virtual ~Product() {
         }
        virtual void say() = 0;
    };
    
    class ConcreteProduct :public Product {
        
    public:
        ConcreteProduct() {
        
            std::cout << "ConcreteProduct..." << std::endl;
        }
        void say() {
        
            std::cout << "ConcreteProduct Say..." << std::endl;
        }
        ~ConcreteProduct() {
         }
    };
    
    // Factory
    
    class Factory {
        
    public:
        virtual Product* CreateProduct() = 0;
        virtual ~Factory() {
         }
    protected:
        Factory() {
         }
    };
    
    class ConcreteFactory :public Factory {
        
    public:
        ConcreteFactory() {
        
            std::cout << "ConcreteFactory..." << std::endl;
        }
    
        ~ConcreteFactory() {
        
    
        }
    
        Product* CreateProduct() {
        
            return new ConcreteProduct();
        }
    
    };
    
    // Test
    
    int main() {
        
        Factory *factory = new ConcreteFactory();
        Product *product = factory->CreateProduct();
        product->say();
    
        delete factory;
        delete product;
    
        return 0;
    }

## 实现 ##

#include <iostream>
    #include <string>
    using namespace std;
    /*
    抽象工厂模式：
    提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类
    */
    class AbstractProduct
    {
        
    public:
    	AbstractProduct() {
        }
    	virtual ~AbstractProduct() {
        }
     
    	virtual void Func() = 0;
    };
     
    class ProductA_1 :public AbstractProduct
    {
        
    public:
    	ProductA_1() {
        }
    	~ProductA_1() {
        }
     
    	virtual void Func() override
    	{
        
    		cout << "ProductA_1 Func" << endl;
    	}
     
    };
    class ProductB_1 :public AbstractProduct
    {
        
    public:
    	ProductB_1() {
        }
    	~ProductB_1() {
        }
     
    	virtual void Func() override
    	{
        
    		cout << "ProductB_1 Func" << endl;
    	}
     
    };
    class ProductA_2 :public AbstractProduct
    {
        
    public:
    	ProductA_2() {
        }
    	~ProductA_2() {
        }
     
    	virtual void Func() override
    	{
        
    		cout << "ProductA_2 Func" << endl;
    	}
     
    };
    class ProductB_2 :public AbstractProduct
    {
        
    public:
    	ProductB_2() {
        }
    	~ProductB_2() {
        }
     
    	virtual void Func() override
    	{
        
    		cout << "ProductB_2 Func" << endl;
    	}
     
    };
    class AbstractFactory
    {
        
    public:
    	AbstractFactory() {
        }
    	virtual ~AbstractFactory() {
        }
    	virtual AbstractProduct* CreatProduct1() = 0;
    	virtual AbstractProduct* CreatProduct2() = 0;
    };
    class FactoryA : public AbstractFactory
    {
        
    public:
    	FactoryA() {
        }
    	~FactoryA() {
        }
     
    	virtual AbstractProduct * CreatProduct1() override
    	{
        
    		return new ProductA_1;
    	}
    	virtual AbstractProduct * CreatProduct2() override
    	{
        
    		return new ProductA_2;
    	}
     
    };
    class FactoryB : public AbstractFactory
    {
        
    public:
    	FactoryB() {
        }
    	~FactoryB() {
        }
     
    	virtual AbstractProduct * CreatProduct1() override
    	{
        
    		return new ProductB_1;
    	}
    	virtual AbstractProduct * CreatProduct2() override
    	{
        
    		return new ProductB_2;
    	}
     
    };
     
    int main()
    {
        
    	//AbstractFactory *f = new FactoryA;
    	AbstractFactory *f = new FactoryB;
     
    	AbstractProduct *p1 = f->CreatProduct1();
    	AbstractProduct *p2 = f->CreatProduct2();
     
    	p1->Func();
    	p2->Func();
     
    	delete f;
    	delete p1;
    	delete p2;
     
    	getchar();
    	return 0;
    }

# 总结 #

## 登场 ##

在工厂模式下有如下角色。通过查看工厂模式的类图，我们可以知道。父类(框架)这一方的Creator角色和Product角色的关系和子类(具体加工)这一方的ConcreteCreator角色和ConcreteProduct角色的关系是平行的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

*  Product(产品)：
    
     *  属于框架这一方，是一个抽象类
     *  它定义了工厂模式中生成的那些实例所持有的接口(API)，但具体的处理则由子类ConcreteProduct角色决定。(`Product`)
 *  Creator(创建者)
    
     *  属于框架这一方，它负责生成Product角色的抽象类，但具体的处理则由子类ConcreteCreator角色决定。（`Factory`）
     *  Creator角色对于实际负责生成实例的ConcreteCreator角色一无所知，它唯一知道的是，只要调用Product角色和生成实例的方法`CreateProduct`，就可以生成具体产品的实例。这里没有用new关键字而是调用生成实例的专用方法CreateProduct来生成实例，这样就可以防止父类和其他具体类耦合。
 *  `ConcreteProduct`（具体的产品）
    
     *  ConcreteProduct角色属于具体加工的这一方，决定了具体的产品
 *  `ConcreteCreator`（具体的创建者）：
 *   *  ConcreteCreator角色属于具体加工的这一方，负责生成具体的产品

[Template Method]: https://blog.csdn.net/zhizhengguan/article/details/119731371
[4739cd77320e44c1aa8d5d938832f8ca.png]: /images/20220829/abf906360ff640db990d4602e4ca26a0.png
[38bd34cd85fc4be3a29408374f295c9f.png]: /images/20220829/2da7154ec5b74a0fbf3be1785f6c725d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20220829/4e05431bec66460b876ddd9e2f9febb1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20220829/79d0159e858444b290fc1c4fb5e70bd0.png