设计模式(1) AbstractFactory

1.意图

提供一个创建一洗了相关或相互依赖对象的接口，而无须指定它们具体实现的类。随着环境或需求的一些变化    ，往往存在着更多系列（重要）的对象的创建。为了避免使用 new 造成硬编码 导致模块间紧耦合，可以使用抽象工厂。抽象工厂不是针对已种产品，而是用于一系列产品类型的变更

2.适用性

(1)一个系统要独立于它的产品的创建，组合和表示时。

(2)一个系统要由多个产品系列中的一个来配置时。

(3)当要强调一系列相关的产品对象的设计以便进行联合使用时.

例子：

#include <iostream>
using namespace std;

class AbstactProductA {

};
class AbstactProductB {

};

class ProductA1 :public AbstactProductA {
public:
	ProductA1() {
		cout << "ProductA1" << endl;
	}
};
class ProductB1 :public AbstactProductB {
public:
	ProductB1() {
		cout << "ProductB1" << endl;
	}
};

class ProductA2 :public AbstactProductA {
public:
	ProductA2() {
		cout << "ProductA2" << endl;
	}
};
class ProductB2 :public AbstactProductB {
public:
	ProductB2() {
		cout << "ProductB2" << endl;
	}
};



class AbstractFactory {
public:
	virtual AbstactProductA* CreateProductA() = 0;
	virtual AbstactProductB* CreateProductB() = 0;

};
//工厂1号 用于生产产品A1和B1
class ConcretFactory1 :public AbstractFactory{
public :
	AbstactProductA* CreateProductA() {
		return new ProductA1();
	}
	AbstactProductB* CreateProductB() {
		return new ProductB1();
	}
};

//工厂2号 用于生产产品A2和B2
class ConcretFactory2 :public AbstractFactory {
public :
	AbstactProductA* CreateProductA() {
		return new ProductA2();
	}
	AbstactProductB* CreateProductB() {
		return new ProductB2();
	}
};

//client 只包含接口
class Client
{
public:
	Client(AbstractFactory* factory) {
		_productA = factory->CreateProductA();
		_productB = factory->CreateProductB();
	}
private:
	AbstactProductA* _productA;
	AbstactProductB* _productB;
};

int main()
{
	AbstractFactory* factory1 = new ConcretFactory1();
	Client a(factory1);

	AbstractFactory* factory2 = new ConcretFactory2();
	Client b(factory2);
}