23种设计模式(2)-AbstractFactory 模式

面向对象的设计原则：高内聚、低耦合

软件重构原则：小步快跑------抽取的思想(抽取函数、抽取类、抽取接口)；对扩展开放、对修改封闭

设计模式分类如下：



2、AbstractFactory 模式

Factory模式创建的产品是相互独立的。若是要创建一组相关的产品，就要用到AbstractFactory 模式。与Factory模式相似，只需要满足每个工厂生产的产品为一组即可，那么不同的工厂就可以生产不同组的产品了。

/*A 类产品*/
class ProductA
{
public:
virtual ~ProductA() = 0;
protected:
ProductA();
};

ProductA::ProductA(){}
ProductA::~ProductA(){}
/*B 类产品*/
class ProductB
{
public:
virtual ~ProductB() = 0;
protected:
ProductB();
};

ProductB::ProductB(){}
ProductB::~ProductB(){}
/*A1*/
class ConcreteProductA1 :public ProductA
{
public:
~ConcreteProductA1();
ConcreteProductA1();
};

ConcreteProductA1::ConcreteProductA1()
{
cout << "ConcreteProduct.." << endl;
}

ConcreteProductA1::~ConcreteProductA1(){}
/*A2*/
class ConcreteProductA2 :public ProductA
{
public:
~ConcreteProductA2();
ConcreteProductA2();
};

ConcreteProductA2::ConcreteProductA2()
{
cout << "ConcreteProduct.." << endl;
}

ConcreteProductA2::~ConcreteProductA2(){}
/*B1*/
class ConcreteProductB1 :public ProductB
{
public:
~ConcreteProductB1();
ConcreteProductB1();
};

ConcreteProductB1::ConcreteProductB1()
{
cout << "ConcreteProduct.." << endl;
}

ConcreteProductB1::~ConcreteProductB1(){}
/*B2*/
class ConcreteProductB2 :public ProductB
{
public:
~ConcreteProductB2();
ConcreteProductB2();
};

ConcreteProductB2::ConcreteProductB2()
{
cout << "ConcreteProduct.." << endl;
}

ConcreteProductB2::~ConcreteProductB2(){}

class Factory
{
public:
virtual ~Factory() = 0;
virtual ProductA* CreateProductA(int n) = 0;
virtual ProductB* CreateProductB(int n) = 0;
protected:
Factory();
};

Factory::Factory(){}
Factory::~Factory(){}

class ConcreteFactory1 :public Factory
{
public:
~ConcreteFactory1();
ConcreteFactory1();
ProductA* CreateProductA(int n = 0);
ProductB* CreateProductB(int n = 0);
};

class ConcreteFactory2 :public Factory
{
public:
~ConcreteFactory2();
ConcreteFactory2();
ProductA* CreateProductA(int n = 0);
ProductB* CreateProductB(int n = 0);
};

ConcreteFactory1::ConcreteFactory1()
{
cout << "concrete factory 1" << endl;
}

ProductA* ConcreteFactory1::CreateProductA(int n)
{//n 可以用宏定义来实现
switch (n)
{
case 0:
return new ConcreteProductA1();
/*
default:
break;
................多个product
*/
}

}
ProductB* ConcreteFactory1::CreateProductB(int n)
{//n 可以用宏定义来实现
switch (n)
{
case 0:
return new ConcreteProductB1();
/*
default:
break;
................多个product
*/
}

}

ConcreteFactory1::~ConcreteFactory1(){}

ConcreteFactory2::ConcreteFactory2()
{
cout << "concrete factory 2" << endl;
}

ProductA* ConcreteFactory2::CreateProductA(int n)
{//n 可以用宏定义来实现
switch (n)
{
case 0:
return new ConcreteProductA2();
/*
default:
break;
................多个product
*/
}

}
ProductB* ConcreteFactory2::CreateProductB(int n)
{//n 可以用宏定义来实现
switch (n)
{
case 0:
return new ConcreteProductB2();
/*
default:
break;
................多个product
*/
}

}

ConcreteFactory2::~ConcreteFactory2(){}

int main()
{
Factory *fac1 = new ConcreteFactory1();
Factory *fac2 = new ConcreteFactory2();
fac1->CreateProductA(0);//A1
fac1->CreateProductB(0);//B1
fac2->CreateProductA(0);//A2
fac2->CreateProductA(0);//B2
return 0;
}

AbstractFactory模式是为创建一组(多个类)提供创建的接口。而Factory模式是为同一类对象提供创建的接口。