浅谈设计模式之一——简单工厂、工厂、抽象工厂

这些天意识自身的不足，看着几个同学跳槽后的高薪，实在是惭愧。毕业两年，仍一事无成，差距也正逐渐体现出来。人们常说，设计模式是一个初级程序员到高级程序员的必经之路。为了补强自己，重新研究了GOF四人帮的<23种设计模式>，其实以前看过，只是没看懂，最近重新研究了一番，理解了一些，希望用通俗易懂的语言把它写下来，或许对初学者有帮助，对自己也有提升。

设计模式分为创建型模式、行为型模式和结构型模式。创建型模式又分为5种，分别是抽象工厂（Abstract Factory）、工厂模式（Factory）、建造者模式（Builder）、原型模式（Prototype）和单例类模式（Singleton）。

注：GOF四人帮的<23种设计模式>中没有简单工厂。

这里从创建型模式讲起，首先讲简单工厂、工厂以及抽象工厂。

一、简单工厂模式（Simple Factory）

首先先上uml图，简单工厂很简单，但不够灵活，其实大家经常用，只是不知道这就是简单工厂。uml图相信大家都看得懂。



解析uml：一个父类产品，几个子类继承父类产品，一个具体工厂依赖具体产品。

这样做的好处就是简单，坏处也很明显，不够灵活，扩展性相对差。实现可以用多态来实现。多态有三个条件：一是父类的virtual，二是子类的覆盖（要求函数名、参数、返回值都要一模一样），三是父类的指针或引用指向子类的对象。

下面给出可执行的参考代码：

SimpleFactory.h

#pragma once
#incldue<iostream>
using namespace std;

const int PRODOCTA=1;
const int PRODOCTB=2;
class AbstractProduct;

class Factory
{
public:
//construct
Factory(void);
//create a product
AbstractProduct * CreateProduct(int flag);

//destruct
~Factory(void);
};

class AbstractProduct
{
public:
virtual void Operation() = 0;

};

class ProductA:public AbstractProduct
{
public:
void Operation();

};

class ProductB:public AbstractProduct
{
public:
void Operation();

};

SimpleFactory.cpp

#include "Factory.h"
Factory::Factory(void)
{
}

Factory::~Factory(void)
{
}

AbstractProduct* Factory::CreateProduct(int flag)
{
switch(flag)
{
case PRODOCTA:
return new ProductA();
break;
case PRODOCTB:
return new ProductB();
break;
default:
return NULL;
break;
}

}

void ProductA::Operation()
{
cout<<"ProductA"<<endl;
}

void ProductB::Operation()
{
cout<<"ProductB"<<endl;
}

main.cpp

#include "Factory.h"
int main(int argc,char** argv)
{
Factory f;
f.CreateProduct(PRODOCTA)->Operation();
f.CreateProduct(PRODOCTB)->Operation();

getchar();
return 0;
}

执行结果：



二、工厂模式（Factory）

同样先上uml图。



uml解析：一个抽象工厂，有若干子工厂泛化，一个抽象产品，若干子产品，工厂跟产品是依赖关系。跟简单工厂相比，多了抽象工厂，使对象实例化延迟到子类。

可以这样理解工厂模式，有很多电脑厂商，比如联想，华硕，dell，苹果等，如果你比较有钱，要生产一台苹果的笔记本，那么你可以通过AppleFactory生产一个AppleProduct，这样做的好处就是不用再传参数了。

下面给出可以直接运行的示例代码：

Factory.h

#pragma once
#include "SimpleFactory.h"

class Factory
{
public:
Factory(void);
~Factory(void);
public:
virtual AbstractProduct * CreateProduct() = 0;

};

class ConcreteFactoryA: public Factory
{
public:
AbstractProduct * CreateProduct();

};

class ConcreteFactoryB: public Factory
{
public:
AbstractProduct *CreateProduct();

};

Factory.cpp

#include "Factory.h"

Factory::Factory(void)
{
}

Factory::~Factory(void)
{
}

AbstractProduct * ConcreteFactoryA::CreateProduct()
{
return new ProductA;
}

AbstractProduct * ConcreteFactoryB::CreateProduct()
{
return new ProductB;
}

main.cpp

#include "Factory.h"

int main(int argc,char** argv)
{
ConcreteFactoryA *f1;
f1 = new ConcreteFactoryA();
ConcreteFactoryB *f2;
f2 = new ConcreteFactoryB();
f1->CreateProduct()->Operation();
f2->CreateProduct()->Operation();

getchar();
return 0;
}

运行结果：


三、抽象工厂（Abstract Factory）

一样先上uml


uml解析：跟工厂的区别就是产品也抽象了，不止一个产品，即工厂跟产品都抽象，而且产品的数量大于等于2。可以这么理解，有华硕，dell，联想，苹果等厂商，你要一个苹果的显示器，联想的主板，dell的鼠标，这时你就可以用到抽象工厂，原因是抽象工厂把鼠标，键盘，显示器等否分开了，以便亲你可以自己定制一个。

下面贴出可直接运行的示例代码：

AbstractFactory.h

#pragma once
#include <iostream>
using namespace std;

class AbstractProductA
{
public:
virtual void Operation() = 0;
};

class AbstractProductB
{
public:
virtual void Operation() = 0;
};

class ConcreteProductA1:public AbstractProductA
{
public:
void Operation();

};

class ConcreteProductA2:public AbstractProductA
{
public:
void Operation();
};

class ConcreteProductB1:public AbstractProductB
{
public:
void Operation();

};

class ConcreteProductB2:public AbstractProductB
{
public:
void Operation();
};

class AbstractFactory
{
public:
AbstractFactory(void);
~AbstractFactory(void);
public:
virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
};

class AbstractFactoryA:public AbstractFactory
{
public:
AbstractProductA * CreateProductA();
AbstractProductB * CreateProductB();
};

class AbstractFactoryB:public AbstractFactory
{
public:
AbstractProductA * CreateProductA();
AbstractProductB * CreateProductB();
};

AbstractFactory.cpp

#include "AbstractFactory.h"

AbstractFactory::AbstractFactory(void)
{
}

AbstractFactory::~AbstractFactory(void)
{
}

AbstractProductA * AbstractFactoryA::CreateProductA()
{
return new ConcreteProductA1();

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

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

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

}

void ConcreteProductA1::Operation()
{
cout<<"concreteProductA1"<<endl;
}
void ConcreteProductA2::Operation()
{
cout<<"concreteProductA2"<<endl;
}
void ConcreteProductB1::Operation()
{
cout<<"concreteProductB1"<<endl;
}
void ConcreteProductB2::Operation()
{
cout<<"concreteProductB2"<<endl;
}

main.cpp

#include "AbstractFactory.h"

int main(int argc,char** argv)
{
AbstractFactory* f1 = new AbstractFactoryA();
AbstractFactory* f2 = new AbstractFactoryB();
f1->CreateProductA()->Operation();
f1->CreateProductB()->Operation();
f2->CreateProductA()->Operation();
f2->CreateProductB()->Operation();

getchar();
return 0;
}

运行结果如图：


好了，到此为止，三种工厂模式就全部介绍完，希望对你有帮助，也希望对自己有帮助，写博客还真是累，给个赞吧O(∩_∩)O~thx