design pattern——abstract factory

model

implement

abstract product

class AbstractProductA
{
protected:
AbstractProductA();

public:
virtual ~AbstractProductA() = 0;
};

class AbstractProductB
{
protected:
AbstractProductB();

public:
virtual ~AbstractProductB() = 0;
};

AbstractProductA::AbstractProductA()
{
}

AbstractProductA::~AbstractProductA()
{
}

AbstractProductB::AbstractProductB()
{
}

AbstractProductB::~AbstractProductB()
{
}

concrete product

class ConcreteProductA1 : public AbstractProductA
{
public:
ConcreteProductA1();
~ConcreteProductA1();
};

class ConcreteProductA2 : public AbstractProductA
{
public:
ConcreteProductA2();
~ConcreteProductA2();
};

class ConcreteProductB1 : public AbstractProductB
{
public:
ConcreteProductB1();
~ConcreteProductB1();
};

class ConcreteProductB2 : public AbstractProductB
{
public:
ConcreteProductB2();
~ConcreteProductB2();
};

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

ConcreteProductA1::~ConcreteProductA1()
{
}

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

ConcreteProductA2::~ConcreteProductA2()
{
}

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

ConcreteProductB1::~ConcreteProductB1()
{
}

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

ConcreteProductB2::~ConcreteProductB2()
{
}

abstract factory

class AbstractFactory
{
protected:
AbstractFactory();

public:
virtual ~AbstractFactory();

public:
virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
};

AbstractFactory::AbstractFactory()
{
}

AbstractFactory::~AbstractFactory()
{
}

concrete factory

class ConcreteFactoryA : public AbstractFactory
{
public:
ConcreteFactoryA();
~ConcreteFactoryA();

public:
AbstractProductA* CreateProductA();
AbstractProductB* CreateProductB();
};

class ConcreteFactoryB : public AbstractFactory
{
public:
ConcreteFactoryB();
~ConcreteFactoryB();

public:
AbstractProductA* CreateProductA();
AbstractProductB* CreateProductB();
};

ConcreteFactoryA::ConcreteFactoryA()
{
cout << "ConcreteFactoryA..." << endl;
}

ConcreteFactoryA::~ConcreteFactoryA()
{
}

AbstractProductA* ConcreteFactoryA::CreateProductA()
{
return new ConcreteProductA1();
}

AbstractProductB* ConcreteFactoryA::CreateProductB()
{
return new ConcreteProductB1;
}

ConcreteFactoryB::ConcreteFactoryB()
{
cout << "ConcreteFactoryB..." << endl;
}

ConcreteFactoryB::~ConcreteFactoryB()
{
}

AbstractProductA* ConcreteFactoryB::CreateProductA()
{
return new ConcreteProductA2();
}

AbstractProductB* ConcreteFactoryB::CreateProductB()
{
return new ConcreteProductB2();
}

应用

void abstractfactory_test()
{
AbstractFactory* factoryA = new ConcreteFactoryA();
AbstractProductA* productAA = factoryA->CreateProductA();
AbstractProductB* productAB = factoryA->CreateProductB();

AbstractFactory* factoryB = new ConcreteFactoryB();
AbstractProductA* productBA = factoryB->CreateProductA();
AbstractProductB* productBB = factoryB->CreateProductB();
}

总结

抽象：concrete productX的公共基类AbstractProductX进行了抽象，concrete factory的公共基类AbstractFactory进行了抽象
扩展：AbstractProductX种类可以进行扩展，每种AbstractProductX的concrete product可以进行扩展，concrete factory可以进行扩展
开发者不需要知道concrete productX和concrete factory，开发者只与公共基类AbstractProductX和公共基类AbstractFactory交互
abstract factory pattern是对factory pattern的扩展，abstract factory pattern和factory pattern的主要区别是abstract factory pattern可以维护多种AbstractProductX，可以对concrete factory进行扩展，而factory pattern维护单种product，concrete factory唯一，无需扩展，因为product种类唯一