Software Design Lecture : 28

Categories of Design Patterns Creational Structural Behavioral

Creational Design Patterns Deal with one of the most commonly performed tasks in an OO application, the creation of objects. Support a uniform, simple, and controlled mechanism to create objects. Allow the encapsulation of the details about what classes are instantiated and how these instances are created. Encourage the use of interfaces, which reduces coupling.

Factory Pattern Problem Statement: When a client object does not know which class to instantiate, it can make use of the factory method to create an instance of an appropriate class from a class hierarchy or a family of related classes. The factory method may be designed as part of the client itself or in a separate class. The class that contains the factory method or any of its subclasses decides on which class to select and how to instantiate it.

Factory Pattern - Description If there exist class hierarchies i-e super / sub classes then client object usually know which class /sub class to instantiate but at times client object know that it needs t instantiate the object but of which class it does not know ; it may be due to many factors The state of the running application Application configuration settings Expansion of requirements or enhancements In such cases, an application object needs to implement the class selection criteria to instantiate an appropriate class from the hierarchy to access its services

Disadvantage of this Approach Because every application object that intends to use the services offered by the class hierarchy needs to implement the class selection criteria, it results in a high degree of coupling between an application object and the service provider class hierarchy. Whenever the class selection criteria change, every application object that uses the class hierarchy must undergo a corresponding change. Shown in the next picture

Solution :Factory Pattern “Factory Pattern defines an interface for creating the object but let the subclass decide which class to instantiate. Factory pattern let the class defer instantiation to the sub class “ It works on the principle of delegation

Solution Description Encapsulating the functionality required, to select and instantiate an appropriate class separately. Selects an appropriate class from a class hierarchy based on the application context and other influencing factor Instantiates the selected class and returns it as an instance of the parent class type This approach will decouple the client from object creation

Factory Method Application objects can make use of the factory method to get access to the appropriate class instance. This eliminates the need for an application object to deal with the varying class selection criteria. Besides the class selection criteria, the factory method also implements any special mechanisms required to instantiate the selected class. This is applicable if different classes in the hierarchy need to be instantiated in different ways. The factory method hides these details from application objects and eliminates the need for them to deal with these intricacies.

Possible Class Diagram of Factory Pattern

Simple Example with Java Code Problem Statement: We want the user to enter the name in either “first name last name or last name, first name” format. We have made the assumption that there will always be a comma between last name and first name and space between first name last name

Class Diagram NameFactory Application Object Namer Passes Parameter Firstfirst Lastfist Handles Creation of Subclass object and return relevant instance of subclass

Sample Code in Java

Namer Class class Namer { protected String last; //store last name here protected String first; //store first name here public String getFirst() return first; //return first name } public String getLast() { return last; //return last name }}

class FirstFirst extends Namer { //split first last public FirstFirst(String s) { int i = s.lastIndexOf(" "); //find sep space if (i > 0) //left is first name first = s.substring(0, i).trim(); //right is last name last =s.substring(i+1).trim(); } else first = “”; // put all in last name last = s; // if no space }}}

class LastFirst extends Namer { //split last, first public LastFirst(String s) { int i = s.indexOf(","); //find comma if (i > 0) //left is last name last = s.substring(0, i).trim(); //right is first name first = s.substring(i + 1).trim(); } else { last = s; // put all in last name first = ""; // if no comma }}}

Building the Factory

class NameFactory { //returns an instance of LastFirst or FirstFirst //depending on whether a comma is found public Namer getNamer(String entry) { int i = entry.indexOf(","); //comma determines name order if (i>0) return new LastFirst(entry); //return one class else return new FirstFirst(entry); //or the other }}

Testing the Factory

public class testFactory { public static void main(String args[]) NameFactory nfactory = new NameFactory(); String name=“Ali khan”; Namer namer = nfactory.getNamer(name); - Delegation //compute the first and last names //using the returned class System.out.println(namer.getFirst()); System.out.println(namer.getLast()); }}