设计模式笔记-创建型模式之三--工厂方法：Factory Method

适用性：

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

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

3当类将创建对象的职责委托给多个帮助子类中的一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候

 

效果：

1不再将与特定应用有关的类邦定到代码中。

2为子类提供挂钩（hook） 用工厂方法在一个类的内部创建对象通常比直接创建对象更灵活。Factory Method给子类一个挂钩以提供对象的扩展版本

3连接平行的类层次

 

实现：

1两种不同情况  1）Creator是抽象类并且不提供它所声明的工厂方法的实现

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

2 参数化工厂方法 工厂方法采用一个标识要被创建的对象种类的参数

3C++中的工厂方法都是虚函数并且常常是纯虚函数

4使用模板以避免创建子类

 

抽象工厂与工厂方法的区别：

 工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。  
                              一个抽象工厂类，可以派生出多个具体工厂类。  
                              每个具体工厂类只能创建一个具体产品类的实例。  
  抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。  
                              一个抽象工厂类，可以派生出多个具体工厂类。  
                              每个具体工厂类可以创建多个具体产品类的实例。  
   
  区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。  
              工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

示例代码如下：

Factory.h

1. #include <string>
2. #define MAX_ROOM_NO 30
4. enum Direction {North,South,East,West,Length};
5. class Mapsite
6. {
7. public:
8.   Mapsite(){}
9.   virtual ~Mapsite(){}
10.   virtual void Enter() = 0;
11. };
14. class Room : public Mapsite
15. {
16. public:
17.   Room(int roomNo);
18.   int GetRoomNo(){return roomNumber;}
19.   Mapsite* GetSide(Direction) const;
20.   void SetSide(Direction,Mapsite*);
21.   virtual void Enter();
22. private:
23.   Mapsite* _sides[4];
24.   int roomNumber;
25. };
27. class EnchantedRoom:public Room
28. {
29. public:
30.     EnchantedRoom(int roomNo);
31. };
33. class Wall:public Mapsite
34. {
35. public:
36.     Wall();
37.     virtual void Enter();
39. };
41. class Door:public Mapsite
42. {
43. public:
44.   Door(Room* = 0,Room* = 0);
45.   virtual void Enter();
46.   Room * OtherSideFrom(Room*);
47. private:
48.   Room* _room1;
49.   Room* _room2;
50.   bool _isOpen;
52. };
54. class EnchantedDoor:public Door
55. {
56. public:
57.     EnchantedDoor(Room* = 0,Room* = 0);
58. };
61. class Maze {
62. public:
63.     //Maze();
64.     void AddRoom(Room *);
65.     Room* RoomNo(int) const;
66. private:
67.     Room *a[MAX_ROOM_NO];
68. };
70. class MazeGame
71. {
72. public:
73.  Maze* CreateMaze();
74. //factory Methods
75.  virtual Maze* MakeMaze() const
76.  {return new Maze;}
77.  virtual Room* MakeRoom(int n) const
78.  {return new Room(n);}
79.  virtual Wall* MakeWall() const
80.  {return new Wall;}
81.  virtual Door* MakeDoor(Room* r1,Room* r2) const
82.  {return new Door(r1,r2);}
84. };
85. class EnchantedMazeGame:public MazeGame
86. {
87. public:
88.   EnchantedMazeGame();
89.   virtual Room* MakeRoom(int n) const
90.   {
91.       return new EnchantedRoom(n);
92.   } 
93.   virtual Door* MakeDoor(Room* r1,Room* r2) const
94.   {
95.       return new EnchantedDoor(r1,r2);
96.   }
97. }; 

Factory.cpp

2. #include <iostream>
3. using namespace std;
4. #include "Factory.h"
6. string Direstr[Length] ={
7.     "North",
8.     "South",
9.     "East",
10.     "West"
11. };
13. Room::Room(int roomNo)
14. {
15.  cout<<"Make "<<roomNo<<" room"<<endl;
16.  roomNumber = roomNo;
17. }
19. EnchantedRoom::EnchantedRoom(int roomNo):Room(roomNo)
20. {
21.  cout<<"Make"<<roomNo<<"Enchanted room"<<endl;
22.  //roomNumber = roomNo;
23. }
25. void Room::SetSide(Direction dire,Mapsite* map)
26. {
27.  cout<<"Build a Wall on Direction "<<Direstr[dire]<<endl;
28. }
29. void Room::Enter()
30. {
31.  cout<<"Room enter"<<endl;
32. }
33. Wall::Wall()
34. {
35.  cout<<"Make a wall"<<endl;
36. }
38. void Wall::Enter()
39. {
40.  cout<<"Wall enter"<<endl;
41. }
43. void Door::Enter()
44. {
45.  cout<<"Door enter"<<endl;
46. }
47. void Maze::AddRoom(Room *r)
48. {
49.  cout<<"Add room to the maze!"<<endl;
50.  a[r->GetRoomNo()]=r;
51. }
53. Room* Maze::RoomNo(int roomNO) const
54. {
55.  for (int i=0;i<MAX_ROOM_NO;i++)
56.  { if (i == roomNO)
57.    if (!a[i])
58.     return a[i];
59.    else
60.     return 0;
61.  }
62.  return 0;
63. }
64. Door::Door(Room* r1,Room* r2)
65. {
66.  cout<<"A door is installed between 2 rooms"<<endl;
67. }
68. EnchantedDoor::EnchantedDoor(Room* r1,Room* r2)
69. {
70.  cout<<"A Enchanted door is installed between 2 Enchanted Rooms"<<endl;
71. }
72. Maze* MazeGame::CreateMaze()
73. {
74.     Maze* aMaze = MakeMaze();
75.     Room* r1 = MakeRoom(1);
76.     Room* r2 = MakeRoom(2);
77.     Door* theDoor = MakeDoor(r1,r2);
78.     aMaze->AddRoom(r1);
79.     aMaze->AddRoom(r2);
80.     r1->SetSide(North,MakeWall());
81.     r1->SetSide(East,theDoor);
82.     r1->SetSide(South,MakeWall());
83.     r1->SetSide(West,MakeWall());
84.     r2->SetSide(North,MakeWall());
85.     r2->SetSide(East,MakeWall());
86.     r2->SetSide(South,MakeWall());
87.     r2->SetSide(West,theDoor);
88.     return aMaze;
89. }
90. EnchantedMazeGame::EnchantedMazeGame()
91. {
92.     cout<<"An enchantedMazegame is created!"<<endl;
93. }

main.cpp

1. #include <iostream>
2. using namespace std;
3. #include "Factory.h"
5. int main()
6. {
7.     MazeGame a;
8.     EnchantedMazeGame b;
9.     cout<<"Start MazeGame"<<endl;
10.     a.CreateMaze();
11.     cout<<"Start EnchantedMazeGame"<<endl;
12.     b.CreateMaze();
13.     return 0;
14. }