CSC/ECE 517 Fall 2009/wiki3 ksm 6

Introduction

A programmer, at the time of designing, usually is concerned about their behavior. But other aspects such as the availability of a particular object at the time when it is required also need to be considered. The rules of creation should be followed. Sometimes, the developers intermix the management of object creation with object instantiation. Using same code for object creation as well as object instantiation, can lead to complexity of code. It has to keep a track of object creation, construction parameters, as well as the use of those objects after creation. This leads to several consequences such as reducing coupling as well as selection of an instantiation scheme early. To address these issues, Factories are used which help to keep the objects cohesive, testable and decoupled. The design becomes flexible and the problem can be split into chunks of manageable pieces.

Overview

In this article,we are going to discuss about Factory method Pattern. We will first look at the objectives of Creational patterns. Then we will have a look at different Creational patterns. We will try to find out how and why the Factory Method Pattern has an edge over other Creational patterns. How Factory method design pattern is implemented in some Object Oriented languages. Finally we will discuss about the uses as well as the contribution of Factory pattern in providing an elegant solution to a problem.

Features

The Gang of Four describes the Factories as Creational patterns. The Creational patterns are used in the creation of objects requiring to make decisions. They help us in encapsulating dynamic decisions regarding the instantiation of a class or the delegation of responsibilty to objects. Sometimes we have to make a choice when we can use more than one creational pattern to a situation. While at times, we can combine multiple patterns simultaneously so that we can use them in our own advantage. Their general classification is:

• Abstract Factory Pattern - It is used in creation of different objects by objects without knowing the classes of objects being created. It is very helpful in working with different complex external entities like (different windowing systems) with similar functionality.

For Example: We have to create a user interface framework that can be used to work on top of multiple operating systems. This is done using an abstract class for each type of widget and then write a concrete subclass for each class (for each supported platform).

• The Builder Pattern - It is used in determining the class of an object .

• The Factory Method Pattern - It is a way by which an object can start the creation of other objects without knowing about their classes.

• The Prototype Pattern - This Pattern is used in creation of customized objects by an object without knowing their class or the details about their creation.

• The Singleton Pattern - It is used in sharing of a common object by multiple objects without even knowing if it already exists.

These general classifications are based on three broad classifications:

• Behavioral Pattern - used to contain variation of behavior.

• Structural Pattern - used to integrate an existing code into new object-oriented design.

• Factory Pattern - used in the creation of objects.

Problem

Let us consider the problem of creating a framework for desktop applications.It will have the following requirements-

• Support provided for operations such as creation, opening, saving etc.

• A consistent set of methods that can be called when the command is given.

• A document interface that is application independent.

• Concrete classes that implement the interface.

• An abstract class providing logic that is application independent.

Solution

• A class providing the methods. Let us call it Application class.

• Providing a class that can be used to encapsulate the required logic in the selection as well as instantiation of classes that are application specific.

• An interface could be provided that can be implemented by the class provided by the programmer. So that the Application class can call the class provided by the programmer without being dependent on it.

• The interface declares a method that can be implemented by the class provided by the programmer in selecting as well as instantiating a class.

• The Application class works through the interface provided by the framework rather than class provided by the programmer.

Code Examples

Java

Let us take an example in which, we have to draw a polygon. The user has to click on the canvas to select the polygon after which the polygon that corresponds to the selected tool is drawn. We are mainly concerned with the code for MouseListener that reacts to the mouse clicks that take place on the canvas. The code can be written in the following way :

                                           public void mouseclicked(MouseEvent e)
                                            {
                                            if(..currentTool is a square..)
                                            else if(..currentTool is triangle..)
                                            elseif(..current tool is rectangle..)
                                            }

Here we are using conditional statements in creation of the polygons. However, this solution is not very elegant.The code can also be written in a way which is more elegant. We can design the selected tool which can act as a factory that can be used to create the polygon corresponding to the selected tool. To do this, we need to add the following method to the Tool class:

                                            public Polygon createPolygon(Point center)

This method creates a polygon of the selected type with the given center. The mouseClicked method can then be modified as :

                                            public void mouseClicked(MouseEvent e)
                                            {
                                            ..get centerPoint..
                                            Polygon p = currentTool.createPolygon(centerPoint);
                                            ..add p to the canvas..
                                             }

We can clearly see that no conditionals are required. We have added a Factory method which is createPolygon method. It has created obect which can be used by MouseListener. The createPolygon method is made abstract in the Tool class since the Tool class has no idea about which type of polygon is to be created. Then subclasses of Tool clas such as SquareTool, TriangleTool, RectangleTool can be created each of them using the createPolygon method to create appropriate type of object.

Ruby

                                                   class GearFactory
                                                       def new() 
                                              if ( ... some condition )
                                                  return Sprocket.new()
                                                          else
                                                     return Cog().new()
                                                  end
                                                    end
                                                     end
                                                 Our client class now becomes:

                                                    class GearUser 
                                              def doSomething(factory )
                                                     ...
                                             my_gear = factory.new()
                                                          ...
                                                      end
                                                         end

Links

• Factory Pattern

• Advantages of Factory method

• Factory Method Pattern

• Creational Patterns in Java

Referances

• Design Patterns Explained: A New Perspective on Object-Oriented Design, Second Edition ,By: Alan Shalloway; James R. Trott.

ISBN-978-0-321-24714-8

• Patterns in Java Vol. 1 /: A Catalog of Reusable Design Patterns Illustrated With UML by Grand, Mark.

• Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development, Third Edition