由浅入深工厂模式
2019-08-19 本文已影响0人
7ee64cf5edb2
[TOC]
工厂模式
简单工厂模式
用一个单独的类来做创造实例的过程，就是简单工厂
#include <iostream>
using namespace std;
class AbstractProduct {
public:
virtual ~AbstractProduct() {}
virtual void Operation() = 0;
};
class ProductA : public AbstractProduct {
public:
void Operation() { cout << "ProductA" << endl; }
};
class ProductB : public AbstractProduct {
public:
void Operation() { cout << "ProductB" << endl; }
};
class Factory {
public:
AbstractProduct* createProduct(char product) {
AbstractProduct* ap = NULL;
switch(product) {
case 'A': ap = new ProductA(); break;
case 'B': ap = new ProductB(); break;
}
return ap;
}
};
int main() {
Factory* f = new Factory();
AbstractProduct* apa = f->createProduct('A');
apa->Operation(); // ProductA
AbstractProduct* apb = f->createProduct('B');
apb->Operation(); // ProductB
delete apa;
delete apb;
delete f;
return 0;
}
缺点：
不符合开闭原则
工厂方法模式
工厂方法模式定义了一个用于创建对象的接口，让子类决定实例化哪一个类
#include <iostream>
using namespace std;
class AbstractProduct
{
public:
virtual ~AbstractProduct(){}
virtual void Operation() = 0;
};
class ProductA : public AbstractProduct
{
public:
void Operation() {cout << "ProductA" << endl;};
};
class ProductB : public AbstractProduct
{
public:
void Operation() {cout << "ProductB" << endl;};
};
class AbstractFactory
{
public:
virtual ~AbstractFactory() {}
virtual AbstractProduct* FactoryMethod() = 0;
};
class FactoryA : public AbstractFactory
{
public:
~FactoryA() {}
ProductA* FactoryMethod(){
return new ProductA();
}
};
class FactoryB : public AbstractFactory
{
public:
~FactoryB() {}
ProductB* FactoryMethod(){
return new ProductB();
}
};
int main(int argc, const char** argv) {
AbstractFactory* fa = new FactoryA();
AbstractProduct* a = fa->FactoryMethod();
a->Operation();
AbstractFactory* fb = new FactoryB();
AbstractProduct* b = fb->FactoryMethod();
b->Operation();
delete a;
delete b;
delete fa;
delete fb;
return 0;
}
抽象工厂模式
抽象工厂模式是工厂方法的进一步深化，在这个模式中，工厂类不单单可以创建一个对象，而是可以创建一组对象。
AbstractFactory（抽象工厂）声明了一组用于创建对象的方法，注意是一组。
ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建对象的方法，生成一组具体对象。
AbstractProduct（抽象产品）：它为每种对象声明接口，在其中声明了对象所具有的业务方法。
ConcreteProduct（具体产品）：它定义具体工厂生产的具体对象。
#include <iostream>
using namespace std;
class AbstractProductA {
public:
virtual ~AbstractProductA(){}
virtual void Operation() = 0;
};
class ProductA1 : public AbstractProductA {
public:
void Operation() {
cout << "ProductA1" << endl;
}
};
class ProductA2 : public AbstractProductA {
public:
void Operation() {
cout << "ProductA2" << endl;
}
};
class AbstractProductB {
public:
virtual ~AbstractProductB(){}
virtual void Operation() = 0;
};
class ProductB1 : public AbstractProductB {
public:
void Operation() {
cout << "ProductB1" << endl;
}
};
class ProductB2 : public AbstractProductB {
public:
void Operation() {
cout << "ProductB2" << endl;
}
};
class AbstractFactory {
public:
virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
virtual ~AbstractFactory(){}
};
class ConcreteFactory1 : public AbstractFactory {
public:
ProductA1* CreateProductA() {
return new ProductA1();
}
ProductB1* CreateProductB() {
return new ProductB1();
}
};
class ConcreteFactory2 : public AbstractFactory {
public:
ProductA2* CreateProductA() {
return new ProductA2();
}
ProductB2* CreateProductB() {
return new ProductB2();
}
};
int main() {
AbstractFactory* af1 = new ConcreteFactory1();
// 具体工厂创建对应的具体产品
AbstractProductA* apa1 = af1->CreateProductA(); // 工厂1创建产品A
apa1->Operation(); // ProductA1
AbstractProductB* apb1 = af1->CreateProductB(); // 工厂1创建产品B
apb1->Operation(); // ProductB1
AbstractFactory* af2 = new ConcreteFactory2();
AbstractProductA* apa2 = af2->CreateProductA(); // 工厂2创建产品A
apa2->Operation(); // ProductA2
AbstractProductB* apb2 = af2->CreateProductB(); // 工厂2创建产品B
apb2->Operation(); // ProductB2
delete apa1;
delete apa2;
delete af1;
delete apb1;
delete apb2;
delete af2;
return 0;
}
对象工厂
当系统中抽象基类中有很多具体子类，采用上述方式扩展成本极高。函数指针通过引入一个从type到函数指针的索引，使得程序实现非常优雅。
参考文章：
