This document discusses the abstract factory pattern, which provides an interface for creating families of related objects without specifying their concrete classes. It describes the intent, applicability, structure, participants, and consequences of the pattern. It also includes sample code that demonstrates how to implement an abstract factory for a maze game, including creating a base MazeFactory class and deriving an EnchantedMazeFactory class from it. The document is intended to explain the abstract factory pattern and how it can be used to configure a system with one of multiple families of products.

1. Department of Computer Science & Engineering in Hanyang University SINCE 2006
Abstract Factor y
HPC and OT Lab.
23.Jan.2007.
M.S. 1st Choi, Hyeon Seok
1

2. Contents
 Creational Patterns
 Introduction
 Structure, Participants and Collaborations
 Consequences
 Implementation
 Sample code
 Related Patterns
 References
High Performance Computing & Object Technology Laboratory in CSE 2

3. Creational Patterns
 Themes
 All encapsulate knowledge about which concrete classes
the system uses
 Hide how instances of these classes are created and put
together
 Creational patterns scope
 Class : Use inheritance to vary the class that’s
instantiated
 Object : Delegate instantiation to another object
High Performance Computing & Object Technology Laboratory in CSE 3

4. Intent of Abstract Factory
 Provide an interface for creating families of related
or dependent objects without specifying their
concrete classes.
WidgetFactory
+CreateScrollBar() Clien
+CreateWindow()
Window
PMWindow MotifWindonw
MotifWidgetFactory PMWidgetFactory
+CreateScrollBar() +CreateScrollBar()
+CreateWindow() +CreateWindow()
ScrollBar
PMScrollBar MotifScrollBar
High Performance Computing & Object Technology Laboratory in CSE 4

5. Applicability
 Independent of how its objects are created,
composed, and represented
 Configured with one of multiple families of
products.
 A family of related objects is designed to be used
together, and you need to enforce this constraint.
 Provide a class library of products, and you want to
reveal just their interfaces, not implementations.
High Performance Computing & Object Technology Laboratory in CSE 5

6. Structure, Participants and Collaborations
Declare an interface
(create product object)
Declare an interface
AbstractFactory
(product object)
+CreateProductA() Client
+CreateProductB()
AbstractProductA
ProductA2 ProductA1
ConcreteFactory1 ConcreteFactory
2
+CreateProductA() +CreateProductA()
+CreateProductB() +CreateProductB()
AbstractProductB
Implement operation
(create product object)
ProductB2 ProductB1
Implement operation
(product object)
High Performance Computing & Object Technology Laboratory in CSE 6

7. Consequences
 Advantages
 Isolate concrete classes.
 Make exchanging product families easy.
 Promote consistency among products.
 Disadvantages
 Supporting new kinds of products is difficult.
High Performance Computing & Object Technology Laboratory in CSE 7

8. Implementation (1/2)
 Factories as singletons
 Application needs only one instance of a
ConcreteFactory
 Creating the products
 ConcreteProduct define a factory method for each
object.
 If many product families are possible, the concrete
factory can be implemented using the prototype pattern.
 Defining extensible factories
 Add a parameter to operation that create objects
ex) Object make (ObjectType type);
High Performance Computing & Object Technology Laboratory in CSE 8

9. Implementation (2/2)
 Factory method and Prototype
AbstractFactor
+CreateProductA() Client
+CreateProductB()
Prototype
(clone)
AbstractProductA
+clone()
ConcreteFactory
1
-ProductA : AbstractProductA
-ProductB : AbstractProductB ProductA2 ProductA1 ProductA3
+CreateProductA () +clone() +clone() +clone()
+CreateProductB ()
Factory
method AbstractProductB
+clone()
ProductB2 ProductB1 ProductB3
+clone() +clone() +clone()
High Performance Computing & Object Technology Laboratory in CSE 9

10. Sample code (1/5)
---
[MazeGame::CreateMaze]--------------------------------------------
Maze *MazeGame::CreateMaze()
{
Maze *aMaze = new Maze();
Room *r1 = new Room(1);
Room *r2 = new Room(2);
Door *theDoor = new Door(r1, r2);
aMaze->AddRoom(r1);
aMaze->AddRoom(r2); // add room
r1->SetSide(North, new Wall); // set side
r1->SetSide(East, theDoor);
r1->SetSide(South, new Wall);
r1->SetSide(West, new Wall);
r2->SetSide(North, new Wall);
r2->SetSide(East, new Wall);
r2->SetSide(South, new Wall);
r2->SetSide(West, theDoor);
return aMaze;
};
High Performance Computing & Object Technology Laboratory in CSE 10

11. Sample code (2/5)
---[Class
MazeFactory]-----------------------------------------------
class MazeFactory
{
public:
MazeFactory();
// Factory method
virtual Maze *MakeMaze() const
{
return new Maze;
}
virtual Wall *MakeWall() const
{
return new Wall;
}
virtual Room *MakeRoom(int n) const
{
return new Room(n);
}
virtual Door *MakeDoor(Room *r1, Room *r2) const
{
return new Door(r1, r2);
}
};
High Performance Computing & Object Technology Laboratory in CSE 11

12. Sample code (3/5)
---
[MazeGame::CreateMaze]--------------------------------------------
// use to MazeFactory
Maze *MazeGame::CreateMaze(MazeFactory &factory)
{
Maze *aMaze = factory.MakeMaze();
Room *r1 = factory.MakeRoom (1);
Room *r2 = factory.MakeRoom(2);
Door *theDoor = factory.MakeDoor(r1, r2);
aMaze->AddRoom(r1);
aMaze->AddRoom(r2);
r1->SetSide(North, factory.MakeWall());
r1->SetSide(East, theDoor);
r1->SetSide(South, factory.MakeWall());
r1->SetSide(West, factory.MakeWall());
r2->SetSide(North, factory.MakeWall());
r2->SetSide(East, factory.MakeWall());
r2->SetSide(South, factory.MakeWall());
r2->SetSide(West, theDoor);
return aMaze;
}
High Performance Computing & Object Technology Laboratory in CSE 12

13. Sample code (4/5)
---[class
EnchantedMazeFactory]--------------------------------------
class EnchantedMazeFactory: public MazeFactory
{
public:
EnchantedMazeFactory();
// overrided to factory method
virtual Room *MakeRoom(int n) const
{
return new EnchantedRoom(n, CastSpell());
}
virtual Door *MakeDoor(Room *r1, Room *r2) const
{
return new DoorNeedingSpell(r1, r2);
}
protected:
Spell *CastSpell() const;
};
High Performance Computing & Object Technology Laboratory in CSE 13

14. Sample code (5/5)
---[class BombedMazeFactory]--------------------------------------
class BombedMazeFactory: public MazeFactory
{
public:
BombedMazeFactory();
// overrided to factory method
virtual Wall *MakeWall() const
{
return new BombedWall;
}
virtual Room *MakeRoom(int n) const
{
return new RoomWithABomb(n);
}
};
MazeGame game;
BombedMazeFactory factory;
game.CreateMaze(factory);
High Performance Computing & Object Technology Laboratory in CSE 14

15. Related Patterns
 Abstract Factory classes are often implemented
with Factory method
 Abstract Factory and Factory can be implemented
using Prototype
 A Concrete factory is often a Singleton
High Performance Computing & Object Technology Laboratory in CSE 15

16. References
[1] Erich Gamma, Richard Helm, Ralph Johnson, John
Vlissides: Design Patterns Elements of Reusable Object-
Oriented Software. Addison Wesley, 2000
[2] 장세찬 : C++ 로 배우는 패턴의 이해와 활용 . 한빛 미디어 ,
2004
[3] Eric Freeman, Elisabeth Freeman, 서환수 역 : Head First
Design Patterns. 한빛 미디어 , 2005
High Performance Computing & Object Technology Laboratory in CSE 16