设计模式 笔记 工厂方法 Factory Methon

//---------------------------15/04/09----------------------------

//factory method 工厂方法-------对象创建型模式

/*

1:意图：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。

Factory Method使一个类的实例化延迟到其子类。

2:别名：
虚构造器(virtual constructor)

3:动机：

4:适用性：

1>当一个类不知道它所必须创建的对象的类的时候。

2>当一个类希望由它的子类来指定它所创建的对象的时候。

3>当类将创建对象的职责委托给多个帮助子类的某一个，并且你希望将哪一个帮助子类是代理者

这一信息局部化的时候。

5:结构：

Product            Creator:

|               FactorMethod()

|               AnOperation(){product = FactoryMethod();...}

|                    |

ConcreteProduct<- - - -ConcreteCreator:

FactoryMethod()

{return new ConcereteProduct;}

6:参与者：

1>Product：定义工厂方法所创建的对象的接口。

2>ConcreteProduct：实现Product接口。

3>Creator：

1)声明工厂方法，该方法返回一个Product类型的对象。Creator也可以定义一个

工厂方法的缺省实现，它可以返回一个缺省的ConcreteProduct对象。

2)可以调用工厂方法以返回一个ConcreteProduct实例。

4>ConcreteCreator：重定义工厂方法以返回一个ConcreteProduct实例。

7:协作：Creator依赖于它的子类来定义工厂方法，所以它返回一个适当的ConcreteProduct实例。

8:效果：

1>工厂方法只提供了一个处理Product的接口，所以

可以和用户定义的任何ConcreteProduct类一起使用。

2>潜在缺点：客户为了创建一个特定的ConcreteProduct对象就不得不创建Creator子类。

3>另外两种效果：

1)为子类提供挂钩(hook)。也就是自己先实现一个默认版本的对象，子类可以根据需求

自行决定是否覆盖父类的版本，自己创建一个特定的对象。

2)连接平行的类层次。(感觉和hook没区别啊<未知标记>)

9:实现：

1>主要有两种不同的情况：

1)Creator类事一个抽象类并且不提供它所声明的工厂方法的实现：

需要子类定义实现，因为没有合理的缺省实现，所以避免了不得

不实例化不可预见类的问题。

2)Creator是一个具体的类并且为工厂方法提供一个缺省的实现：

子类可以在必要时改变父类所实例化的对象的类，所以很灵活。

2>参数化工厂方法：提供一个参数来决定实例化什么特定的类：               */

class Creator

{

public:

virtual Product* Create(ProductId);

};

Product* Creator::Create(ProductId id)

{

if(id == MINE)
returnnew MyProduct;

if(id == YOURS)
returnnew YourProduct;

return
;

}

//        子类可以这么重定义：

Product* MyCreator::Create(ProductId id)

{

if(id == YOURS)
returnnew MyProduct;

if(id == MINE)
returnnew YourProduct;

if(id == THEIRS)
returnnew TheirProduct;

return Create::Create(id);

}

//        记得最后要调用父类的Create，因为，子类可能有些情况没有处理到，必须交给父类来处理。

//      3>使用模版避免创建子类：

template<class  TheProduct>

class StandardCreator:public Creator

{

public:

virtual Product* Create()

{

return
new TheProduct;

}

};

/*

这样客户就可以自己提供产品类放入模版中。而不需要我们创建Creator的子类。

4>命名约定：使用命名约定是一个好习惯，它可以清楚地说明你正在使用的工厂方法。

10:代码示例：                                                            */

//Creator：

class MazeGame

{

public:

Maze* CreateMaze();

virtual Maze* MakeMaze()
const

{return
new Maze;}

virtual Room* MakeRoom(int n)const

{return
new Room(n);}

virtual Wall* MakeWall()
const

{return
new Wall;}

virtual Door* MakeDoor(Room* r1, Room* r2)
const

{return
new Door(r1,r2);}

};

//Maze Room Wall Door 都是Product

//ConcreteCreator：

class BombedMazeGame :public MazeGame

{

public:

BombedMazeGame();

virtual Wall* MakeWall()
const

{return
new BombedWall;}

virtual Room* MakeRoom(int n)const

{return
new RoomWithABomb(n);}

};

//如果客户想要一个带Bombed的迷宫，只需要创建一个BombedMazeGame调用CreateMaze即可。