工厂模式是一种创建型设计模式，通过封装对象的创建过程，提高代码的可维护性、可扩展性，并实现对象的创建与使用的解耦。
简单工厂模式： 提供一个工厂类，根据传入的参数来决定创建哪种产品类的实例。这种模式不符合开闭原则，因为每次添加新产品类型都需要修改工厂类。
class products {
public:int money = 0;virtual void sell() = 0;
};
class apple :public products {
public:void sell() {money += 10;}
};
class banana :public products {
public:void sell() {money += 20;}
};
class factory {
public:static products* get_product(int d) {switch (d) {case 0:return new apple;case 1:return new banana;}return nullptr;}
};
工厂方法模式：定义一个创建产品的接口，由子类决定实例化哪个产品类。每个具体工厂类对应一个具体产品类，符合开闭原则，但客户端需要知道具体工厂类。
class products {
public:virtual void sell() = 0;
};class factory {
public:virtual products* get_product() = 0;
};class apple :public products{
public:void sell(){std::cout << "apple" << std::endl;}
};class banana :public products {
public:void sell() {std::cout << "banana" << std::endl;}
};class apple_producter:public factory {
public:products* get_product() {return new apple;}
};class banana_producter:public factory {
public:products* get_product() {return new banana;}
};
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式通过工厂接口创建一族产品，有多个具体工厂类对应不同的产品族，符合开闭原则且客户端无需知道具体工厂和产品类。
class products {
public:virtual void show() = 0;
};
//抽象产品族
class fruit :public products {};class apple :public fruit {
public:void show() {std::cout << "apple" << std::endl;}
};class banana :public fruit {
public:void show() {std::cout << "banana" << std::endl;}
};
//抽象产品族
class vegetable :public products {};class potato :public vegetable {
public:void show() {std::cout << "potato" << std::endl;}
};class tomato :public vegetable {
public:void show() {std::cout << "tomato" << std::endl;}
};class factory {
public:virtual fruit* get_fruit() = 0;virtual vegetable* get_vegetable() = 0;
};class farm1:public factory {
public:fruit* get_fruit() {return new apple;}vegetable* get_vegetable() {return new potato;}
};class farm2:public factory {
public:fruit* get_fruit() {return new banana;}vegetable* get_vegetable() {return new tomato;}
};
工厂模式的优点
-
封装和隐藏实现细节： 工厂模式将对象的创建过程封装在一个独立的类或方法中，使得客户端代码无需了解对象的具体实现细节。这种封装提高了代码的抽象性，隐藏了实现细节，使系统更加模块化，降低了耦合度。
-
易于扩展： 工厂模式使得系统更容易扩展，当需要添加新的对象类型时，只需修改工厂类或方法而不需要修改客户端代码。这有利于遵循开闭原则，即对扩展开放，对修改关闭。
-
单一职责原则： 工厂模式有助于遵循单一职责原则，即一个类应该只有一个原因引起变化。工厂负责对象的创建，客户端负责对象的使用，这样各自的职责清晰明确，使得代码更易于理解和维护。
-
代码复用： 工厂模式促进了代码的重用。对象的创建逻辑被集中在一个地方，可以在多个地方共享相同的创建逻辑，避免了重复的代码。
-
依赖注入： 工厂模式使得依赖注入更容易实现。通过将对象的创建交给工厂，可以更方便地在需要时注入不同实现的对象，而无需直接修改客户端代码。
-
抽象层的引入： 工厂模式引入了一个抽象层，客户端通过这个抽象层与具体的对象实现解耦。这种解耦提高了代码的灵活性，使得客户端更容易适应变化。
)
