CSC/ECE 517 Fall 2007/wiki3 5 ab: Difference between revisions
No edit summary |
|||
| Line 81: | Line 81: | ||
==Creator vs Factory Pattern== | ==Creator vs Factory Pattern== | ||
==Conclusion== | |||
To conclude, creator pattern is an example of GRASP patterns | |||
==References== | ==References== | ||
Revision as of 04:51, 19 November 2007
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 colectively 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 oject oriented design and hence having a good design associated with proper delegation of object creations would result in maximum reuse and minimum coupling. To figure out which class should be delegated the resposibility of creating objects, the folowing 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 example below of creator pattern has been taken from the site "www.ugolandini.net" . 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 data and item and an item SaleLineItem which represents a sold item. It contains an attribute quantity. Since the Sale class contains a number of objects of type class SaleLineItem, considering rule 1 , class Sale should be assigned the resposibility of creating objects of type SaleLineItem. To implement such a creation a method might be added in Sale class called makeLineItem() which invokes the constructor of SaleLineItem 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 DataRows to a DataTable. To obtain a new row object, the DataTable class is asigned the responsibility of creating new rows to the table. 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 provides a very simple explanation of the GRASP creator pattern.
2) 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.
3) The book Aplying UML and Patterns provides an illustration of Creator pattern and again gives the same 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 http://www.soc.napier.ac.uk/module.php3?op=getresource&cloaking=no&resourceid=5938601#267,20,Creator , 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
Creator vs Factory Pattern
Conclusion
To conclude, creator pattern is an example of GRASP patterns
References
1. http://blogs.msdn.com/sanjeets/archive/2007/09/02/creational-factory-pattern.aspx
2. http://davidhayden.com/blog/dave/archive/2004/12/06/667.aspx
3. http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)#Factory
4. http://web.cs.wpi.edu/~gpollice/cs4233-a05/CourseNotes/maps/class4/Creator.html
5. http://gsraj.tripod.com/design/creational/factory/factory.html
7. http://www.apwebco.com/gofpatterns/creational/FactoryMethod.html
10. http://faculty.inverhills.edu/dlevitt/CS%202000%20(FP)/GRASP%20Patterns.pdf
11. http://www.ondotnet.com/pub/a/dotnet/2003/08/11/factorypattern.html
12. http://www.mindspring.com/~mgrand/pattern_synopses2.htm
13. http://www.oodesign.com/oo_design_patterns/creational_patterns/factory_method.html
14. http://www.codeproject.com/useritems/BuilderPattern.asp
15. http://www.cs.purdue.edu/homes/jv/510s05/patterns.pdf
16. http://www-plan.cs.colorado.edu/danielvd/paper/gpce03.pdf