[设计模式]创建模式-工厂模式(C++描述)

[设计模式]创建模式-工厂模式(C++描述)

second60 20180424

1. 什么是创建者模式

创建模式是设计模式中三类之一，主要是为了对象的创建而产生的一系列设计模式。

包括：

a) Factory Pattern: 工厂模式

b) AbstartFactory: 抽象工厂

c) Singleton:单例

d) Builder:创建者

e) Prototype:原型模式

 

这五类创建者模式都很常用，至少在我做过的项目中，都见遇到过。最常用的有：单例，工厂，抽象工厂。

下面我会一个一个详细介绍，并写下自已的经验。

 

2. 什么是Factory Pattern

2.1 由例子引发

例子：某工厂造出了A类机器人，名字为RobotA，不久，又造出了B类机器人，名字为RobotB，后面还会造出不同类型的机器要,C,D,E,F.....

 

分析：

a) 在面向对象中，通常会做的第一件事就是把类进行抽象，形成抽象基类，抽象父类。

对上面的机器人抽象，抽象类为Robot，子类分别为：RobotA,RobotB

b) 继续分析，工厂可以造机器人，但造什么类型的机器人是不清楚的，要看上级的具体安排。因此，名为工厂的类RobotFactory，可以先产机器人。

 

总结，工厂模式

1. 创建对象的接口

2. 使得具体化类延迟到子类中。

 

2.2 简单工厂模式

工厂类：生产产品 RobotFactory

产品抽象类： Robot

具体产品类：RobotA  RobotB

 

图我这里就不画了，没装rose，百度搜一个。

 

为了代码易看，就不分头和内容了，只要看懂了就OK：

// 抽象机器人类

class Robot

{

public:

Robot(){}

virtual ~Robot() = 0; // virtual一定要加，我就不多解释了

};

// 实体机器人A

class RobotA:public Robot{};

// 实体机器人B

class RobotB:public Robot{};

// 新加机器人C

class RobotC:public Robot{};

 

// 机器人工厂类:专门用来生产机器人

class RobotFactory

{

public :

Robot*  createRobot(int robotType)

{

Robot * robotPtr = NULL:

switch(robotType)

{

case 1:robotPtr = new RobotA();

case 2:robotPtr = new RobotB();

case 3:robotPrt = new RobotC();// 新加机器人C

}

return robotPtr;

}

};

简单工厂写完了，说说他的优缺点吧

 

2.2.1优点：

1. 抽象出了产品类，后续新加新产品，只需增加一个类并继承即可

2. 工厂类提供了一个生产产品的地方，具体生产什么产品，由延迟子类决定

曾通做法,没有工厂类：

Robot* robotA = new RobotA();

Robot* robotB = new RobotB();

Robot* robotC = new RobotC();

没有工厂类，那么使用对象的人，需要关心具体是什么子类，要知道子类的名字叫什么。

 

但有工厂类的好处：

RobotFactory * factoryPtr = new RobotFactory();

Robot* robotA = factoryPtr.createRobot(EROBOT_A);

Robot* robotB = factoryPtr.createRobot(EROBOT_B);

Robot* robotC = factoryPtr.createRobot(EROBOT_C);

这样开发人员无须知道子类的名字，无须关心子类是什么样的。只需关心我创建出来的是机器人就OK了， 至于想创建什么样的机器人，由开发人员自已决定，。

 

2.2.2缺点：

1. 如果新加一个机器人C，是要修改工厂类滴createRobot，如果工厂类是一个公共部份，那么改动将会影响到其他的对象创建，至少测试时，要把之前涉及的用例都测一随。

上面代码红色部分为新加一个机器人C

 

有什么办法来避象简单工厂的缺点呢，就是不用改动任何代码，新增机器人也没问题呢。答安是当然有，就是升级版工厂模式。

 

2.3 进阶处工厂模式

怎么样来避免简单工厂新增机器人会改动到工厂类的办法呢？其实也就是不用在更改任何之前代码的情况下，新加机器人C，机器人D....

 

答案很简单：抽象啊！！！！（学设计模式的目的之一）

是的，我们再把工厂类抽象出来。

进阶工厂模式图（百度的）：

 

其他的不变，只是把Factory类抽象了出来，具体的工厂，由具体的工厂实现类去做。

代码如下：

// 抽象机器人类

class Robot

{

public:

Robot(){}

virtual ~Robot() = 0; // virtual一定要加，我就不多解释了

};

// 实体机器人A

class RobotA:public Robot{};

// 实体机器人B

class RobotB:public Robot{};

 

// 把机器人工厂类抽象出来

class RobotFactory

{

public :

 

RobotFactory(){}

virtual ~RobotFactory() = 0;

virtual Robot*  createRobot() = 0;

};

 

// 生产机器人A的工厂

class RobotFactoryA: public RobotFactory

{

public:Robot*  createRobot(){return new RobotA();}

};

// 生产机器人B的工厂

class RobotFactoryB: public RobotFactory

{

public:Robot*  createRobot(){return new RobotB();}

};

 

// 新加机器人C

class RobotC:public Robot{};

// 生产机器人C的工厂

class RobotFactoryC: public RobotFactory

{

public:Robot*  createRobot(){return new RobotC();}

};

 

int main()

{

// 机器人A在A工厂生产

RobotFactory *factoryA = new RobotFactoryA();

Robot *robotA = factoryA.creatRobot();

// 机器人B在B工厂生产

RobotFactory *factoryB = new RobotFactoryB();

Robot *robotB = factoryB.creatRobot();

// 新加机器人C在C工厂生产

RobotFactory *factoryC = new RobotFactoryC();

Robot *robotC = factoryC.creatRobot();

//delete 不写了

}

2.3.1 优点

a) 扩展和维护性好：新增机器人,无须再修改原逻辑,上面红色部份(是不是很强大，没有修改任何逻辑，只加了机器人C，和工厂C，就可以支持新的机器人了，这就是设计模式的强大之处了)

 

2.3.2 缺点

a) 需要增加一个新工厂类的代价，如果产品很多，工厂类也会很多。当然，你也可以只有一个工厂类，在工厂类里创建不同机器人，新加不同方法。但这又回归到简单工厂了。

 

2.4 总结

工厂模型是创建模型的一种。

工厂模型的好处：

1. 具产品抽象化

2. 延迟了子类的实例化

3. 易用性：开发者无须关心具体的产品，只需用工厂生产即可

4. 易扩展，易维护：进阶工厂模型，可以不改任何代码的情况下，新增产品

 

工厂模型的局限性：

1. 只能对一类产品进行创建

 

3 后话

这里举了上机器人创建的举子，是我随时发挥的一个例子。我也不知道自已写的是不是很明白，尽量很简单的写，让人明白，为什么会有工厂模式，工厂模式的好处是什么，同时，让人了解设计模式的强大的特点，抽象化，可扩展，可维护。后续继讲抽象工厂模式，能解决工厂模式的局限性问题。

夜深了，人更静了。