7.工厂方法模式

1.简介

工厂模式是一种创建型设计模式，用于动态的创建对象。

组成部分：

抽象产品
声明具体产品的接口，放在稳定的方法里
具体产品
产品接口的实现
抽象工厂
提供创建产品的接口，放在稳定的方法里
具体工厂
用于创建具体的产品

如果有一个稳定的方法，里面有一个产品对象，当我们需要使用A产品时要在代码里new A，如果想要在里面使用B产品时要new B，这违反了开闭原则，不应该修改代码，工厂模式是为了解决这一问题。

2.问题

现在有一个产品A类、产品B类和一个用于检查产品的CheckProduct类，当我想检查产品A时如下代码

//-----------------
// 产品
//-----------------
// 抽象产品类
class Product {
public:
	virtual ~Product() = default;

	// 展示类信息 抽象方法
	virtual void showInfo() = 0;

};

// 具体产品类A
class ProductA : public Product {
public:
	// 重写 showInfo 方法
	void showInfo() {
		std::cout << "ProductA" << std::endl;
	}

};

// 具体产品类B
class ProductB : public Product {
public:
	// 重写 showInfo 方法
	void showInfo() {
		std::cout << "ProductB" << std::endl;
	}

};


// -----------------
// CheckProduct 类
// -----------------
class CheckProduct {
public:
	// 检查产品
	void check() {
		Product *product = new ProductA;
		product->showInfo();
		delete product;
	}
};

假设 CheckProduct 是稳定的，当我们想 check ProductB 是就需要 new ProductB，这样会修改CheckProduct，这样就不太好。

如何使用工厂模式解决上面的问题？

3.使用工厂模式

根据依赖倒置原则，CheckProduct是稳定的，就不能依赖ProductA，因为不稳定，而是依赖Product这个抽象的类，但是这样不能使用new创建产品对象。

为了能创建对象，除了new还可以使用方法返回一个对象。这个创建产品对象的对象就是工厂，用于创建产品对象。

具体实现看代码

产品

// 抽象产品类
class Product {
public:
	virtual ~Product() = default;
	
	// 展示类信息 抽象方法
	virtual void showInfo() = 0;

};

// 具体产品类A
class ProductA : public Product {
public:
	// 重写 showInfo 方法
	void showInfo() {
		std::cout << "ProductA" << std::endl;
	}
};

// 具体产品类B
class ProductB : public Product {
public:
	// 重写 showInfo 方法
	void showInfo() {
		std::cout << "ProductB" << std::endl;
	}
};

工厂

// 抽象工厂
class Factory {
public:
	virtual ~Factory() = default;
	
	// 返回产品的抽象类
	virtual Product* createProduct() = 0;
};

// A工厂
class FactoryA : public Factory {
public:
	// 重写 createProduct 方法
	Product* createProduct() {
		return new ProductA;
	}
};

// B工厂
class FactoryB : public Factory {
public:
	// 重写 createProduct 方法
	Product* createProduct() {
		return new ProductB;
	}

};

CheckProduct 类

class CheckProduct {
public:
	Factory *factory;   // 工厂
	
	CheckProduct(Factory *factory) {
		this->factory = factory;
	}
	
	~CheckProduct() {
		delete factory;
	}
	
	// 检查产品
	void check() {
		Product *product = factory->createProduct();
		product->showInfo();
		delete product;
	}
};

main

int main(int argc, char const *argv[])
{
	// 工厂A
	FactoryA *f_A = new FactoryA;
	
	// CheckProduct 对象
	CheckProduct *check_p = new CheckProduct(f_A);
	check_p->check();   // 输出 ProductA
	
	 // 工厂B
	FactoryB *f_B = new FactoryB;
	check_p->factory = f_B;
	check_p->check();   // 输出 ProductB
	
	delete check_p;
	delete f_A;
	delete f_B;
	return 0;
}

这样做的好处是保护了CheckProduct对象，即使在添加新产品对象时也不需要修改CheckProduct。

CheckProduct类有一个factory成员变量，用于创建产品对象，factory由外部传入，保证CheckProduct的稳定。

1.简介

2.问题

3.使用工厂模式

猜你喜欢