设计模式中创建型模式

相关的类图结构：

一直在看创建型，现在看的有两种模式:
Abstract factory（抽象工厂模式）
Builder(生成器模式）
这里用一个迷宫程序来说明这两种模式。
类MapSite是所有迷宫组件的公共抽象类。为简化例子，MapSite仅定义了一个操作Enter.
如果你进入一个房间，那么你的位置会发生改变。如果你试图进入一扇门，那么这两件事中
就会有一件发生：如果门是开着的，你进入另一个房间，如果门是关着的，那么你就会碰壁。
Room是MapSite的一个具体的子类，而MapSite定义了迷宫中构件之间的主要关系。
Room有指向其它MapSite对象的引用，并保存一个房间号，这个数字用来标识迷宫中的房间。
Enter为更加复杂的游戏操作提供了一个简单基础。例如，如果你在一个房间中说“向东走”，
游戏只能确定直接在东边的是哪一个MapSite并对它进行调用Enter.特定子类的Enter操作将计算
出你的位置是发生改变还是你会碰壁。在一个真正的游戏中，Enter可以将移动的游戏者作为一个参数。

我们定义的另一个类是MazeGame，由它来创建迷宫。一个简单直接的创建迷宫的方法是使用一系列的操作
将构件增加到迷宫中，然后连接它们。例如，下面的成员函数将创建一个迷宫，这个迷宫由两个房间和它们之间
的一扇门组成。Maze* MazeGame::CreateMaze()，这样的代码比较直接，属硬编
码方式
MazeFactory是一个创建迷宫的类工厂，它将创建迷宫的细节隐藏在这个工厂中，建造迷宫的程序将MazeFactory作为一个参数，这样程序员就能指定要创建的房间，墙壁和门等类。
MazeBuilder类则是采用一步步建造所有部件的方式来建迷宫。
abstract factory
意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
它分离了具体的类，将客户与类的实现分离
它使得晚于交换产品系列
它有利于产品的一致性
难以支持新种类的产品
创建时常春藤用的一些技术：
1、将工厂作为单件
2、创建产品 。
以下将使用Abstract Factory模式创建我们前面所讨论的迷宫
类MazeFactory可以创建迷宫的组件。它建造房间，墙壁和房间之间的门。它可以
用于一个从文件中读取迷宫说明书图并建造迷宫的程序。或者它可以被用于一个
随机建造迷宫的程序。

Abstract Factory与Builder相似，因为它也可以创建复杂对象。主要的区别在于Builder模式
着重于一步步构造一个复杂对象。而Abstract Factory着重于多个系列的产品对象。Builder
在最后的一步返回产品，而对于Abstract Factory来说，产品是立即返回的。另外，Builder模式每一步产生一个组件，在其内部组合成一个对象后返回该对象。而Abstract Factory则是返回一系列的产品对象，内部不进行组合的动作，这是它们之间的最大的区别。

以下为相关代码，可以比较这两种模式的区别。

// MapSite.h
#pragma warning(disable:4786)


#include < vector >
#include < map >
using namespace std;

// ##ModelId=48059C2800E6
class MapSite
... {
public:
//##ModelId=48059C280105
virtualvoidEnter()=0;
} ;

// ##ModelId=48059C280115
enum Direction
... {
North,South,East,West
} ;

// ##ModelId=48059C280134
class Room: public MapSite
... {
public:
//##ModelId=48059C280144
Room(introomNo)...{_roomNumber=0;}
//##ModelId=48059C280146
MapSite*GetSide(Directiond)const...{return_sides[d];}
//##ModelId=48059C280154
voidSetSide(Directiond,MapSite*s)...{_sides[d]=s;}

//##ModelId=48059C280157
virtualvoidEnter()...{printf("Room::Enter()");}

//##ModelId=48059C280159
intGetRoomNo()const...{return_roomNumber;}
private:
//##ModelId=48059C280164
MapSite*_sides[4];
//##ModelId=48059C280168
int_roomNumber;
} ;


// ##ModelId=48059C280172
class Wall: public MapSite
... {
public:
//##ModelId=48059C280183
Wall()...{}
//##ModelId=48059C280184
virtualvoidEnter()...{printf("Wall::Enter()");}
} ;


// ##ModelId=48059C280191
class Door: public MapSite
... {
public:
//##ModelId=48059C2801A1
Door(Room*r1=0,Room*r2=0)...{_room1=r1;_room2=r2;}

//##ModelId=48059C2801A4
virtualvoidEnter()...{printf("Door::Enter()");};
//##ModelId=48059C2801A6
Room*OtherSideFrom(Room*);
private:
//##ModelId=48059C2801A9
Room*_room1;
//##ModelId=48059C2801B2
Room*_room2;
//##ModelId=48059C2801B6
bool_isOpen;
} ;

// ##ModelId=48059C2801C0
class Maze
... {
public:
//##ModelId=48059C2801D0
Maze()...{}

//##ModelId=48059C2801D1
voidAddRoom(Room*r)
...{
maproom[r->GetRoomNo()]=r;
}
//##ModelId=48059C2801D3
Room*RoomNo(intno)...{returnmaproom[no];}

private:
//##ModelId=48059C2801EF
map<int,Room*>maproom;
//
} ;


// 建造迷宫的程序将MazeFactory作为一个参数，这样程序员就能指定要创建的房间，
// 墙壁和门等类
// ##ModelId=48059C2801FF
class MazeFactory
... {
public:
//##ModelId=48059C280200
MazeFactory()...{}

//##ModelId=48059C280201
virtualMaze*MakeMaze()const
...{
returnnewMaze;
}
//##ModelId=48059C280203
virtualWall*MakeWall()const
...{
returnnewWall;
}
//##ModelId=48059C28020F
virtualRoom*MakeRoom(intn)const
...{
returnnewRoom(n);
}
//##ModelId=48059C280212
virtualDoor*MakeDoor(Room*r1,Room*r2)const
...{
returnnewDoor(r1,r2);
}
} ;


// 创建各个部件，作用类似于MazeGame::CreateMaze();
// ##ModelId=48059C28021E
class MazeBuilder
... {
public:
//##ModelId=48059C28021F
virtualvoidBuildMaze()...{}
//##ModelId=48059C280221
virtualvoidBuildRoom(introom)...{}
//##ModelId=48059C28022F
virtualvoidBuildDoor(introomFrom,introomTo)...{}

//##ModelId=48059C280233
virtualMaze*GetMaze()...{return0;}
protected:
//##ModelId=48059C280235
MazeBuilder()...{}

} ;

class StandardMazeBuilder: public MazeBuilder
... {
public:
StandardMazeBuilder()...{_currentMaze=0;}

virtualvoidBuildMaze()...{_currentMaze=(Maze*)newStandardMazeBuilder;}
virtualvoidBuildRoom(int);
virtualvoidBuildDoor(int,int);

virtualMaze*GetMaze()...{return_currentMaze;}
private:
DirectionCommonWall(Room*,Room*);//决定哪两个相邻的墙可以有门。
Maze*_currentMaze;
} ;

void StandardMazeBuilder::BuildRoom( int n)
... {
if(!_currentMaze->RoomNo(n))
...{
Room*room=newRoom(n);
_currentMaze->AddRoom(room);

room->SetSide(North,newWall);
room->SetSide(South,newWall);
room->SetSide(East,newWall);
room->SetSide(West,newWall);
}
}

void StandardMazeBuilder::BuildDoor( int n1, int n2)
... {
Room*r1=_currentMaze->RoomNo(n1);
Room*r2=_currentMaze->RoomNo(n2);
Door*d=newDoor(r1,r2);

r1->SetSide(CommonWall(r1,r2),d);

分享到：

UML中的用例图分析 | servlet和JSP过滤器Filter(全)

• 2008-04-15 18:45
• 浏览 168
• 评论(0)
• 相关推荐

评论

发表评论

您还没有登录,请您登录后再发表评论