工厂模式

最新推荐文章于 2025-05-21 09:02:05 发布

maomao171314

最新推荐文章于 2025-05-21 09:02:05 发布

阅读量126

点赞数

分类专栏：设计模式文章标签：工厂模式工厂方法模式抽象工厂模式

本文链接：https://blog.youkuaiyun.com/maomao171314/article/details/118156843

版权

设计模式专栏收录该内容

6 篇文章

订阅专栏

本文介绍了三种工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式。简单工厂模式通过一个工厂类创建所需的产品对象；工厂方法模式则将创建对象的职责委托给子类，增加了灵活性；抽象工厂模式关注一系列相关产品的创建，提供了一组工厂方法来创建一个产品族。这些模式在软件设计中用于降低耦合性和提高可扩展性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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 工厂方法模式优缺点

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