Creational Design Patterns

Creational Design Patterns Creational DP:

Abstracts the instantiation process Helps make a system independent of how

objects are created, composed, represented. Two types

1. Class creationalUses inheritance to vary the class to be instantiated

2. Object creationalDelegates instantiation to another object

Creational Patterns

Creational Patterns are important as systems depend more on object composition

Creational Patterns Encapsulate concrete classes system

uses Hide how instances of these classes

are created

Example: To build a Maze

Maze exampleinterface Site

{ void enter() ; }class Room implements Site

{ public Room(int number) { roomNumber = number ; } public Site getSide(int direction) { return sides[direction] ; } public void setSide(int direction, Site m) { sides[direction] = m ; } public void enter() { } private Site[] sides = new Site[4] ; private int roomNumber ; }

class Wall implements Site{ public Wall() { } public void enter() { } }

class Door implements Site{ public Door(Room r1, Room r2) { room1 = r1 ; room2 = r2 ; } public void enter() { } private Room room1, room2 ; private boolean isOpen ; }

Maze Exampleclass Maze{

public static int NORTH = 0 ;public static int SOUTH = 1 ;public static int EAST = 2 ;public static int WEST = 3 ;

public Maze(){ }

public void addRoom(Room r){ rooms.add(r) ; }

public Room roomNo(int idx){ return (Room) rooms.get(idx) ; }

List rooms = new ArrayList() ;}

Maze Exampleclass MazeGame{

public Maze createMaze() {

Maze maze = new Maze() ;Room room1 = new Room(1) ;Room room2 = new Room(2) ;Door door = new Door(room1,room2) ;

maze.addRoom(room1) ;maze.addRoom(room2) ;

room1.setSide(Maze.NORTH,new Wall()) ;room1.setSide(Maze.EAST ,door) ;room1.setSide(Maze.SOUTH,new Wall()) ;room1.setSide(Maze.WEST ,new Wall()) ;

room2.setSide(Maze.NORTH,new Wall()) ;room2.setSide(Maze.EAST ,new Wall()) ;room2.setSide(Maze.SOUTH,new Wall()) ;room2.setSide(Maze.WEST ,door) ;

return maze ;}

}

Factory Method Intent: Define an interface for creating an

object, but let subclasses decide which cass to instantiate.

Motivation: Example: Framework of Abstract classes

Abstract classes: Document, Application Application has Open, New, etc. to create new

documents Application cannot know which concrete document to

instant Concrete classes: DrawingDocument,

DrawingApplication

Complex “Constructors”class Complex {

public static Complex fromCartesian(double real, double imag) {

return new Complex(real, imag);

} public static Complex fromPolar(double modulus, double

angle) { return new Complex(modulus * cos(angle), modulus * sin(angle));

} …

Complex c = Complex.fromPolar(1, pi); // fromCartesian(-1, 0)

Factory Method Solution

CreateDocument() = Factory Method

Factory Method

Applicability: Use the Factory Method when

A class can’t anticipate the class of objects it must create

A class wants its subclasses to specify the objects it creates

Factory Method

Factory Method - Participants

Product (Document) The interface of objects the Factory Method

creates ConcreteProduct (MyDocument)

Implements the product interface Creator (Application)

Declares the factory method which returns an object of type Product

ConcreteCreator (MyApplication) Defines the Factory method to returnn an

instance of ConcreteProduct

Factory Method Implementation

Abstract Creator Class v.s. Concrete Creator Class

Parameterized Factory Method Creator can keep the Class Info to

instantiate (Can avoid sub classing)

To use naming conventions

Factory Methods in Maze Example

public class MazeGame{

Maze newMaze(){ return new Maze() ; }

Room newRoom(int n){ return new Room(n) ; }

Wall newWall(){ return new Wall() ; }

Door newDoor(Room r1, Room r2){ return new Door(r1,r2) ; }

public Maze createMaze() {Maze maze = newMaze() ;Room room1 = newRoom(1) ;Room room2 = newRoom(2) ;Door door = newDoor(room1,room2) ;………………return maze ;

}}

Customized Maze Componentsclass BombedWall extends Wall {}

class RoomWithABomb extends Room {

RoomWithABomb(int n){ super(n) ; }

}

class BombedMazeGame extends MazeGame {Wall newWall()

{ return new BombedWall() ; }Room newRoom(int n)

{ return new RoomWithABomb(n) ; }}

Abstract Factory Intent: Provides an interface for creating

families of related or dependent objects without specifying their concrete classes.

Motivation: User interface Toolkit supporting multiple

look-and- feel standards. (Widgets like Scroll Bars, Windows, Buttons etc.)

Not to hard code these widgets for a particular look-and-feel otherwise hard to change it

We can define a WidgetFactory interface for creating each basic entity

Abstract Factory Example

Abstract Factory - Applicability

Use Abstract Factory if A system must be independent of how its

products are created A system should be configured with one

of multiple families of products A family of related objects must be used

together You want to reveal only interfaces of a

family of products and not their implementations

Abstract Factory - Structure

Abstract Factory - Participants

AbstractFactory (WidgetFactory) Declares an interface of methods to create abstract

product objects ConcreteFactory (MotifWidgetFactory,…)

Implements the methods to create concrete product objects

AbstractProduct (Window, ScrollBar) Declares an interface for a product type

ConcreteProduct (MotifWindow, MotifScrollBar) Defines a product object Implements the AbstractProduct interface

Client Uses only interfaces declared by AbstractFactory and

AbstractProduct

Abstract Factory Implementation

Factory better to be a Singleton A new Concrete Factory for each

Platform.Or alternatively a single Concrete Factory keeping its Classes of Products.

Extending the Factories. (Adding a new Product)

Abstract Factory – Maze Example

class MazeFactory {Maze newMaze()

{ return new Maze() ; }Room newRoom(int n)

{ return new Room(n) ; }Wall newWall()

{ return new Wall() ; }Door newDoor(Room r1, Room r2)

{ return new Door(r1,r2) ; }}public class MazeGame{

public Maze createMaze(MazeFactory factory) {Maze maze = factory.newMaze() ;Room room1 = factory.newRoom(1) ;Room room2 = factory.newRoom(2) ;Door door = factory.newDoor(room1,room2) ;………………return maze ;

}}

Customizing Maze Factoryclass BombedWall extends Wall {}

class RoomWithABomb extends Room {RoomWithABomb(int n)

{ super(n) ; }}

class BombedMazeFactory extends MazeFactory {Wall newWall()

{ return new BombedWall() ; }Room newRoom(int n)

{ return new RoomWithABomb(n) ; }}

Singleton Intent: Ensure that a class has only one

instance, and provide a global point of access to it.

Use Singleton There must be exactly one instance of a

class, and it must be accessible to clients from a well known access point.

When this instance should be extensible by sub-classing

Singleton

Singleton Define an Instance operation to access its

unique instance. It must be a static method. Must create its own unique instance.

Singleton - benefits

Controlled access to sole instance Reduced namespace May be sub-classed to refine

operations Can Permit a variable number of

instances More flexible than static methods

Singleton – Implementation

Ensure a unique instanceclass Singleton {

private static Singleton inst = null ;public static Singleton getInstance() { if (inst==null) inst = new Singleton() ; return inst ;}protected Singleton() { }

} Subclassing the singleton class

Put instance() method in each subclass

Singleton – Maze exampleclass MazeFactory {

protected MazeFactory(){ }

private static MazeFactory inst = null ;public static MazeFactory getInst()

{ if (inst==null)inst = new MazeFactory() ;

return inst ; }Maze newMaze()

{ return new Maze() ; }Room newRoom(int n)

{ return new Room(n) ; }Wall newWall()

{ return new Wall() ; }Door newDoor(Room r1, Room r2)

{ return new Door(r1,r2) ; }}

Singleton – Maze examplepublic class MazeGame{

public Maze createMaze() {Maze maze = MazeFactory.getInst().newMaze() ;Room room1 = MazeFactory.getInst().newRoom(1) ;Room room2 = MazeFactory.getInst().newRoom(2) ;Door door = MazeFactory.getInst().newDoor(room1,room2) ;

maze.addRoom(room1) ;maze.addRoom(room2) ;

room1.setSide(Maze.NORTH,new Wall()) ;room1.setSide(Maze.EAST ,door) ;room1.setSide(Maze.SOUTH,new Wall()) ;room1.setSide(Maze.WEST ,new Wall()) ;

room2.setSide(Maze.NORTH,new Wall()) ;room2.setSide(Maze.EAST ,new Wall()) ;room2.setSide(Maze.SOUTH,new Wall()) ;room2.setSide(Maze.WEST ,door) ;

return maze ;} }

Singleton – Alternative Maze Factory

class MazeFactory {protected MazeFactory()

{ }private static final String name = "BOMBED" ;private static MazeFactory inst = null ;public static MazeFactory getInst()

{ if (inst==null) {if (name.equals("BOMBED"))

inst = new BombedMazeFactory() ;else

inst = new MazeFactory() ; } return inst ; }

Maze newMaze(){ return new Maze() ; }

Room newRoom(int n){ return new Room(n) ; }

Wall newWall(){ return new Wall() ; }

Door newDoor(Room r1, Room r2){ return new Door(r1,r2) ; }

}