CSC/ECE 517 Fall 2007/wiki3 5 ab

Problem Statement

Take the Creator pattern and catalog the information on it available on the Web. Explain how it is different from the Factory pattern. Find good descriptions and good, concise, understandable examples. Tell which you consider the best to present to a class

Introduction

The creator design pattern is a part of the family of design patterns collectively referred to as (GRASP) General Responsibility Assignment Software Patterns. The various patterns or principles associated with GRASP are creator, controller, low coupling, high cohesion, polymorphism and Factory pattern. These patterns are critical to any software development project. We specifically look into the creator pattern of GRASP and compare it with the factory pattern.

The Creator Pattern

The creator pattern under GRASP is mainly associated with delegating the creation of an object of a certain class to another responsible class. Object creations is one of the most important aspects of object oriented design and hence a good design should be associated with proper delegation of object creations to appropriate classes so that it results in maximum reuse and minimum coupling. To figure out which class should be delegated the responsibility of creating objects of another class, the following set of rules should be followed.

A certain class X should be associated with creating objects of class Y if any of the following is true

1)Class X contains objects of class Y.

2)Class X aggregates objects of class Y.

3)Class X records instances of class Y.

4)Class X owns the initialization data which helps in creating objects of class X.

5)Class X makes good use of objects of class Y.

Following examples have been illustrated to show the implementation of the Creator pattern. These examples have been documented from various resources available on the web. If you will notice very limited resources are available on the web about creator pattern and those that are there,document the same example. This page however tries to document some of those unique examples.

Example 1

The class diagram shown below of creator pattern has been taken from the site www.ugolandini.net . This example actually has been taken from the book Applying UML and Patterns by Craig Larman. Most of the examples on the web document this same example as is illustrated later on.

The above diagram illustrates a class Sale which contains attributes date and item and an item SaleLineItem which represents an item which is sold and it contains an attribute quantity. Since the Sale class contains a number of objects of type class SaleLineItem, considering rule 1 given above , class Sale should be assigned the responsibility of creating objects of class SaleLineItem. To implement such a creation a method might be added in Sale class called makeLineItem() which invokes the constructor of SaleLineItem class. Since this example has been used in most resources on the web and it is actually used originally in the book Applying UML and Patterns, it would be safe to say that this could be expressed as the best example to be used to explain to a class.

Example 2

The following code snippet has been taken from a lecture slide at www.cs.purdue.edu The Maze class consists of rooms and hence it is given the responsibility of creating instances of Class Room.

Maze create() {
Maze maze = new Maze();
Room r1 = new Room(1);
Room r2 = new Room(2);
Door door = new Door(r1, r2);
maze.addRoom(r1); 
maze.addRoom(r2);
r1.setSide(North, new Wall()); 
r1.setSide(East, door);
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, door);
return maze;
}

Example 3

This example has been taken from the reource by DavidHayden . He illustrates the creation of new Rows to a DataBase Table. To obtain a new Row object, the DataTable class is asigned the responsibility of creating new rows to the table. This is a result of applying Rule 1 as given above. Since the DataTable class contains many DataRow objects, it should be the class which creates objects of type DataRow. The following code snippet elaborates on this.

DataRow myRow = myTable.NewRow();
...
Rows.Add(myRow);

Other examples on the web

A few more resources, which document about the creator pattern are as follows:

1) wikipedia This page introduces the usage of GRASP patterns. The creator pattern is explained in some detail but the factory pattern could be illustrated by an example.

2) The lecture notes at staff.cs.utu illustrates on the example given in Craig larman's book. It provides in depth exposure on the subject and illustrates how the low coupling and high cohesion pattern influences the usage of Creator pattern. This page is a also a good page to start learning about GRASP.

3) The course notes in web.cs.wpi.edu also gives an explanation of creator pattern by illustrating the same example of the Sale class given in Example 1.

4) The following page by Jeffrey Blessing is a good page which explains the idea of GRASP patterns. It illustrates all the patterns with simple examples related to the Sale class example.

5) The lecture slides on www.soc.napier.ac.uk illustrate the idea of GRASP patterns and further illustrates how creator pattern promotes low coupling .

6)Lecture slides at iastate.edu, also illustrate on the GPASP patterns and provide examples for Creator pattern.

7) The following page at www.informit.com provides illustrative examples of GRASP pattern using the same example but this page is more educative and would be a good resource to learn about GRASP in general.

8) Lecture slides at cs.uwindsor.ca again provides an overview of GRASP but it gives a very general outline , more illustrative examples could have been provided.

9) Lecture slides by Yohan Welikala provides another illustrative resource of GRASP patterns. It provides a different example to elaborate the Creator pattern . The example used is of that of a Digital Library which contains a LendingDatabase class which contains LendingRecords and hence creates instances of LendingRecords class.

10) Lecture slides at www.dcs.bbk.ac.uk is another resource which describes about GRASP. This page has some further discussions about Creator pattern and how it relates to Low Coupling.

Creator vs Factory Pattern

As explained in wikipedia, both the creator and factory patterns are members of the family of GRASP Patterns . While the creator pattern is associated with assigning which class is responsible for creating objects of other classes, the factory pattern actually determines through some inbuilt logic to determine,which class should be made responsible for creating new objects. The difference is made more clear with the resource in patterndepot.com which gives good examples of factory pattern. An example given in this page illustrates the use of factory pattern which returns an instance of either firstname followed by lastname class or an instance of lastname followed by firstname class depending on the logic executed by the factory pattern class. If you try to use the creator pattern in this example given in the resource, it wont be of much use since it is not known until the logic is actually executed as to which instance of class is actually needed to be created. To summarize the factory pattern is used when

1) A class cannot easily determine which kind of class objects it should create. (This logic is handled by the factory class which returns the appropriate instance of a particular class.)

2) A class uses its subclasses to specify which object is should create.

3) Parameters can be passed to the factory class which would help it determine which class instance to return.