abstract factory petterns

Department of Computer Science & Engineering in Hanyang University SINCE 2006

11

Abstract Factory

HPC and OT Lab.HPC and OT Lab.23.Jan.2007.23.Jan.2007.

M.S. 1M.S. 1stst Choi, Hyeon Seok Choi, Hyeon Seok

High Performance Computing & Object Technology Laboratory in CSE 22

ContentsContents

Creational PatternsCreational Patterns

IntroductionIntroduction

Structure, Participants and CollaborationsStructure, Participants and Collaborations

ConsequencesConsequences

ImplementationImplementation

Sample codeSample code

Related PatternsRelated Patterns

ReferencesReferences


Creational PatternsCreational Patterns

ThemesThemes

All encapsulate knowledge about which concrete classes All encapsulate knowledge about which concrete classes the system usesthe system uses

Hide how instances of these classes are created and put Hide how instances of these classes are created and put togethertogether

Creational patterns scopeCreational patterns scope

ClassClass : : Use inheritanceUse inheritance to vary the class that’s to vary the class that’s instantiatedinstantiated

ObjectObject : Delegate instantiation to another object : Delegate instantiation to another object


+CreateScrollBar()+CreateWindow()

WidgetFactory


MotifWidgetFactory


PMWidgetFactory

Clien

Window

ScrollBar

PMWindow MotifWindonw

PMScrollBar MotifScrollBar

Intent of Abstract FactoryIntent of Abstract Factory

Provide an interface for Provide an interface for creating families of related creating families of related or dependent objectsor dependent objects without specifying their without specifying their concrete classes.concrete classes.


ApplicabilityApplicability

IndependentIndependent of how its objects are created, of how its objects are created, composed, and representedcomposed, and represented

Configured with Configured with one of multiple familiesone of multiple families of products. of products.

A family of related objects is designed to be used A family of related objects is designed to be used together, and you need to together, and you need to enforce this constraintenforce this constraint..

Provide a class library of products, and you want to Provide a class library of products, and you want to reveal just their reveal just their interfaces, not implementationsinterfaces, not implementations..


Structure, Participants and Structure, Participants and CollaborationsCollaborations

+CreateProductA()+CreateProductB()

AbstractFactory


ConcreteFactory1


ConcreteFactory2

Client

AbstractProductA

AbstractProductB

ProductA2 ProductA1

ProductB2 ProductB1

Declare an interface(create product object)

Implement operation(create product object)

Declare an interface(product object)

Implement operation(product object)


ConsequencesConsequences

AdvantagesAdvantages

IsolateIsolate concrete classes. concrete classes.

Make Make exchangingexchanging product families easy. product families easy.

PromotePromote consistency among products. consistency among products.

DisadvantagesDisadvantages

Supporting new kinds of products is Supporting new kinds of products is difficultdifficult..


Implementation (1/2)Implementation (1/2)

Factories as singletonsFactories as singletons Application needs Application needs only one instanceonly one instance of a ConcreteFactory of a ConcreteFactory

Creating the productsCreating the products ConcreteProduct define a ConcreteProduct define a factory methodfactory method for each object. for each object. If many product families are possible, the concrete factory can be If many product families are possible, the concrete factory can be

implemented using the implemented using the prototype patternprototype pattern..

Defining extensible factoriesDefining extensible factories Add a parameter to operation that create objectsAdd a parameter to operation that create objects ex) Object make (ex) Object make (ObjectTypeObjectType type); type);


Implementation (2/2)Implementation (2/2)

Factory method and Prototype Factory method and Prototype


AbstractFactor


-ProductA : AbstractProductA-ProductB : AbstractProductB

ConcreteFactory1

Client

+clone()

AbstractProductA

+clone()

AbstractProductB

+clone()

ProductA2

+clone()

ProductA1

+clone()

ProductB2

+clone()

ProductB1

+clone()

ProductA3

+clone()

ProductB3

Prototype(clone)

Factorymethod


Sample code (1/5)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;};



---[Class MazeFactory]-----------------------------------------------

class MazeFactory { public:

MazeFactory();// Factory methodvirtual 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);}

};



---[MazeGame::CreateMaze]--------------------------------------------

// use to MazeFactoryMaze *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;}



---[class EnchantedMazeFactory]--------------------------------------

class EnchantedMazeFactory: public MazeFactory { public:

EnchantedMazeFactory();

// overrided to factory methodvirtual 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;

};



---[class BombedMazeFactory]--------------------------------------

class BombedMazeFactory: public MazeFactory { public:

BombedMazeFactory();

// overrided to factory methodvirtual Wall *MakeWall() const { return new BombedWall;}

virtual Room *MakeRoom(int n) const { return new RoomWithABomb(n);}

};

MazeGame game;BombedMazeFactory factory;game.CreateMaze(factory);


Related PatternsRelated Patterns

Abstract Factory classes are often implemented Abstract Factory classes are often implemented with with Factory methodFactory method

Abstract Factory and Factory can be implemented Abstract Factory and Factory can be implemented using using PrototypePrototype

A Concrete factory is often a A Concrete factory is often a SingletonSingleton


ReferencesReferences

[1] Erich Gamma, Richard Helm, Ralph Johnson, John [1] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides: Design Patterns Elements of Reusable Object-Vlissides: Design Patterns Elements of Reusable Object- Oriented Software. Addison Wesley, 2000Oriented Software. Addison Wesley, 2000

[2] [2] 장세찬 장세찬 : C++: C++ 로 배우는 패턴의 이해와 활용로 배우는 패턴의 이해와 활용 . . 한빛 미디어한빛 미디어 , 2004, 2004

[3] Eric Freeman, Elisabeth Freeman, [3] Eric Freeman, Elisabeth Freeman, 서환수 역 서환수 역 : Head First : Head First Design Patterns. Design Patterns. 한빛 미디어한빛 미디어 , 2005, 2005

abstract factory petterns

Technology

new wall r2setsidenorth

new wall r2setsideeast

new wall r2setsidewest

new wall r2setsidesouth

concrete factory

new wall r1setsidewest

createmazemazefactory

new doorr1