工厂模式

1.工厂模式

工厂方法模式是一种创建型设计模式， 其在父类中提供一个创建对象的方法， 允许子类决定实例化对象的类型。

1.1简单工厂模式

简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。

简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为。

在软件开发中，当我们会用到大量的创建某种、某类或者谋批对象时，就会使用到工厂模式。

/* 关键代码：创建过程在工厂类中完成。 */ #include //定义产品类型信息 typedef enum {     Product_Type_APPLE,     Product_Type_XIAOMI,     Product_Type_Num }Product_Type; //抽象产品类 class Product { public:     virtual const std::string Operation() = 0; }; //具体的产品类 class ProductApple : public Product { public:     ProductApple():Product(),m_strType("Apple")     {     }     // 在派生类的成员函数中使用override时，如果基类中无此函数，或基类中的函数并不是虚函数，编译器会给出相关错误信息。     const string& type() override     {         cout << m_strType.data() << endl;         return m_strType;     } private:     std::string m_strType; }; //具体的产品类 class ProductXiaoMi : public Product { public:     ProductXiaoMi():Product(),m_strType("XiaoMi")     {     }     const string& type() override     {         cout << m_strType.data() << endl;         return m_strType;     } private:     string std::m_strType; }; //工厂类 class ProductFactory { public:     //根据产品信息创建具体的产品类实例，返回一个抽象产品类     Product* createProduct(Product_Type type)     {         switch(type)         {         case Product_Type_APPLE:             return new ProductApple();         case Product_Type_XIAOMI:             return new ProductXiaoMi();         default:             return nullptr;         }     } }; int main() {     ProductFactory* factory = new ProductFactory();     ProductApple* apple = factory->createProduct(Product_Type_APPLE);     apple->type();     ProductXiaoMi* xiaomi = factory->createTank(Product_Type_XIAOMI);     xiaomi->type();     delete apple;     apple = nullptr;     delete xiaomi;     xiaomi = nullptr;     delete factory;     factory = nullptr;     return 0; }

1.2、工厂方法模式

定义一个创建对象的接口，其子类去具体现实这个接口以完成具体的创建工作。如果需要增加新的产品类，只需要扩展一个相应的工厂类即可。

缺点：产品类数据较多时，需要实现大量的工厂类，这无疑增加了代码量。

/* 关键代码：创建过程在工厂类中完成。 */ #include //定义产品类型信息 typedef enum {     Product_Type_APPLE,     Product_Type_XIAOMI,     Product_Type_Num }Tank_Type; //抽象产品类 class Product { public:     virtual const std::string Operation() = 0; }; //具体的产品类 class ProductApple : public Product { public:     ProductApple():Product(),m_strType("Apple")     {     }     // 在派生类的成员函数中使用override时，如果基类中无此函数，或基类中的函数并不是虚函数，编译器会给出相关错误信息。     const string& type() override     {         cout << m_strType.data() << endl;         return m_strType;     } private:     std::string m_strType; }; //具体的产品类 class ProductXiaoMi : public Product { public:     ProductXiaoMi():Product(),m_strType("XiaoMi")     {     }     const string& type() override     {         cout << m_strType.data() << endl;         return m_strType;     } private:     string std::m_strType; }; //抽象工厂类，提供一个创建接口 class ProductFactory { public:     //提供创建产品实例的接口，返回抽象产品类     virtual Product* createProductFactory() = 0; }; //具体的创建工厂类，使用抽象工厂类提供的接口，去创建具体的产品实例 class AppleProductFactory :public ProductFactory { public:     //根据产品信息创建具体的产品类实例，返回一个抽象产品类     Product* createProductFactory()     {         return new ProductApple();     } }; class XiaoMiProductFactory :public ProductFactory { public:     //根据产品信息创建具体的产品类实例，返回一个抽象产品类     Product* createProductFactory()     {         return new ProductXiaoMi();     } }; int main() {     ProductFactory* factoryApple = new AppleProductFactory();     ProductApple* apple = factoryApple->createProduct();     apple->type(); ProductFactory* factoryXiaoMi = new XiaoMiProductFactory();     ProductXiaoMi* xiaomi = factoryXiaoMi->createTank();     xiaomi->type();     delete apple;     apple = nullptr;     delete xiaomi;     xiaomi = nullptr;     delete factoryApple;     factoryApple = nullptr; delete factoryXiaoMi;     factoryXiaoMi = nullptr;     return 0; }

1.3、抽象工厂模式

抽象工厂模式提供创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

当存在多个产品系列，而客户端只使用一个系列的产品时，可以考虑使用抽象工厂模式。

缺点：当增加一个新系列的产品时，不仅需要现实具体的产品类，还需要增加一个新的创建接口，扩展相对困难。

/* * 关键代码：在一个工厂里聚合多个同类产品。 * 以下代码以白色手机和黑色手机为例，白色手机为一个产品系列，黑色手机为一个产品系列。白色手机使用白色手机壳，黑色使用黑色手机壳。 * 每个系列的手机由一个对应的工厂创建，这样一个工厂创建的手机能保证手机为同一个系列。 */ //抽象上衣类 class Phone { public:     virtual const string& color() = 0; }; //黑色手机类 class BlackPhone : public Phone { public:     BlackCoat():Phone(),m_strColor("Black Phone")     {     }     const string& color() override     {         cout << m_strColor.data() << endl;         return m_strColor;     } private:     std::string m_strColor; }; //白色手机类 class WhitePhone : public Phone { public:     WhiteCoat():Phone(),m_strColor("White Phone")     {     }     const string& color() override     {         cout << m_strColor.data() << endl;         return m_strColor;     } private:     std::string m_strColor; }; //抽象手机壳类 class PhoneShell { public:     virtual const string& color() = 0; }; //黑色手机壳 class BlackPhoneShell : public PhoneShell { public:     BlackPhoneShell():PhoneShell(),m_strColor("Black PhoneShell")     {     }     const string& color() override     {         cout << m_strColor.data() << endl;         return m_strColor;     } private:     std::string m_strColor; }; class WhitePhoneShell: public PhoneShell { public:     WhitePhoneShell():PhoneShell(),m_strColor("White PhoneShell")     {     }     const string& color() override     {         cout << m_strColor.data() << endl;         return m_strColor;     } private:     std::string m_strColor; }; class Factory { public:       virtual Phone* creatPhone() = 0;        virtual PhoneShell* createPhoneShell() = 0; }; class WhiteFactory : public Factory { public:     Phone* createPhone() override     {         return new WhitePhone();     }     PhoneShell* createPhoneShell() override     {         return new WhitePhoneShell();     } }; class BlackFactory : public Factory {     Phone* createPhone() override     {         return new BlackPhone();     }     PhoneShell* createPhoneShell() override     {         return new BlackPhoneShell();     } };

1.4 工厂方法模式优缺点

优点	缺点
可以避免创建者和具体产品之间的紧密耦合。	应用工厂方法模式需要引入许多新的子类， 代码可能会因此变得更复杂。 最好的情况是将该模式引入创建者类的现有
单一职责原则。 可以将产品创建代码放在程序的单一位置， 从而使得代码更容易维护。
开闭原则。 无需更改现有客户端代码，就可以在程序中引入新的产品类型。