CSC/ECE 517 Fall 2012/ch2b 2w60 ns
Factory Method
Overview of the Pattern
Factory method pattern is an Object Oriented Programming concept in which objects can be created without specifying the class to which they belong.Factory method pattern implement the concept of using an object to generate other objects.<ref name="web">http://www.oodesign.com/factory-pattern.html
</ref>Factory method is thus a type of creational pattern. An interface is defined for object creation. However the subclasses decide which class they want to instantiate. Factory methods thus abstract object instantiation from the client.<ref name="userpagesfactory">http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf
</ref>
Creating an object often requires complex processes not appropriate to include within a composing object. The object's creation may lead to a significant duplication of code, may require information not accessible to the composing object, may not provide a sufficient level of abstraction, or may otherwise not be part of the composing object's concerns. The factory method design pattern handles these problems by defining a separate method for creating the objects, which subclasses can then override to specify the derived type of product that will be created.
Directory of Sites
1. Factory method pattern (Wikipedia)
http://en.wikipedia.org/wiki/Template_method_pattern
Wikipedia<ref name="wikipedia">http://en.wikipedia.org/wiki/Template_method_pattern </ref> is much more detailed, it goes into the motivation for the pattern and discusses use of the patterns in several languages such as Java and C# at a high level.
2. Factory Method Design Pattern(dofactory.com)
http://www.dofactory.com/Patterns/PatternFactory.aspx
This article has two interesting sections. The first one is the section called “Participants”, which explains the different components involved in a Factory method. Most other articles do not specify the components in the patter. The other interesting thing about the article is that , code snippets in different programming languages have been provided at the end of the article, this helps us learn how the same problem can be addressed in different paradigms.
3. Factory Method (oodesign.com)
http://www.oodesign.com/factory-method-pattern.html
This article starts off by describing the Factory method by giving a real-life application example as a motivation. It then shows us the UML structure of it and the corresponding implementation. What stands out in this article is detailed example towards the end of the article. It describes a “Documents Application” example which is targeted to frameworks in desktop applications. It describes at length as to how different documents will be required to be instantiated in a different way and how the application will be unaware of this. It then proposes to solve the problem with Factory method design pattern. And also illustrates the implementation. It also highlights the issues which one might come across while implementing the Factory method which is interesting. This article is beneficial because the example shows us how in some cases we require to postpone the object creation decision to the subclasses and how this is achieved through the Factory method.
4.Factory Method Design Pattern(codeproject.com)
http://www.codeproject.com/Articles/184765/Factory-Method-Design-Pattern
This article explains the Factory method through an example and is very intuitive. It describes as to how if you are the middle man or an online book store and a customer is buying a book from an online store , you would want to choose a distributor to have the book shipped to the customer based on some predefined criteria , without making the customer aware of these details an explains how this can be done in a seamless way by using the Factory method. This example and implementation makes the concept of Factory method very clear and also illustrates the fact that the implementation details should be hidden from the clients (the customer placing the order for a book in this case). This example illustrates the idea and the structure of the Factory method better than most other sites as it is very simple to understand and structured well unlike the other articles which pick more complicated examples.
5.Using Factory Method Pattern in Java (javapapers.com)
http://javapapers.com/design-patterns/factory-method-pattern
javapapers<ref name="javapapers">http://javapapers.com/design-patterns/factory-method-pattern/</ref> is a good page that gives a basic overview of the pattern through the presentation of a concrete example in java language. There are other Java resources and resources for other languages that are similar below.
6.Factory Method(sourcemaking.com)
http://sourcemaking.com/design_patterns/factory_method
7.Java- Factory Method(blog)
http://javarevisited.blogspot.com/2011/12/factory-design-pattern-java-example.html
8.Article on Factory method
http://gsraj.tripod.com/design/creational/factory/factory.html
This article explains the motivation behind using the Factory method in brief but focuses more on the implementation details of it. There are real-life examples provided as applications. This link is a good learning tool if one wants a running example of the full implementation details of the Factory method. Most other links focus just on the concept without providing the code for the implementation details. That issue has been well addressed in this article.
9.Head First Design Patterns (Text Book)
https://docs.google.com/viewer?url=http%3A%2F%2Foreilly.com%2Fcatalog%2Fhfdesignpat%2Fchapter%2Fch03.pdf
10.youtube link
http://www.youtube.com/watch?v=yDEmb5XYc_s&feature=related
This is a small video demonstrating the use of Factory method. This video helps us learn two important problems that we would encounter if we did not use Factory method, and then explains how the Factory method solves this problem. The two issues addressed in this video are, if we do not use the Factory design pattern it becomes imperative that the client knows all the implementation details and hence extensibility would be a problem in the future, the other problem it focuses on is maintainability of the code, as instantiating all potential classes with the “new” keyword can make code complex and difficult to maintain. The author demonstrates as to how these issues can be addressed using the Factory method. http://en.wikipedia.org/wiki/Factory_method_pattern - This is a wiki article on Factory methods, this gives a good explanation of the “definition” of Factory methods and description of the situation in which Factory method would come handy.
Summary
For a general overview and UML diagrams of the Factory method design pattern, we recommend:
Ruby
Summary
Java & C#
There are a variety of resources available for learning how to use the Factory method pattern in Java and C#. We group these together as they are syntactically similar languages. One of the most popular references for learning about Design Patterns in Java is the book "Head First Design Patterns"<ref name="head_first"> https://docs.google.com/viewer?url=http%3A%2F%2Foreilly.com%2Fcatalog%2Fhfdesignpat%2Fchapter%2Fch03.pdf </ref>; in this book an in-depth explanation of the Factory method Pattern can be found. This is probably more popular because of how in-depth its explanation is of the design pattern, using diagrams and an ongoing coding example. If you are interested in learning about the Factory method pattern for Java and/or C# but do not have enough time or energy to read the chapter in the "Head First Design Patterns"<ref name="head_first"/> book, there are other resources that can be used to achieve an understanding but are less textual. Most of the resources that are not highly verbose use an over-arching example to explain the pattern. A good and simple resource for learning how to use the Factory method pattern in Java can be found on the site SourceMaking, a site devoted to teaching IT concepts such as Design Patterns and UML to professional developers<ref name="sourcemaking"> http://sourcemaking.com/design_patterns/factrory_method/c%2523 - 2012?</ref>. This resource includes a number of Java (and C#) examples meant to explain the usage of the pattern as well as textual explanations if needed. An advantage to using this resource is that it uses less text and more examples to show how the Factory method pattern can be used. It is also helpful that this site has multiple examples that can help increase understanding through reinforcement and multiple viewpoints (and languages). A disadvantage to using this site is that all of the examples are general examples using the pattern as opposed to real life situations or scenarios.
Some sites use over-arching real life examples to explain the Factory method pattern and its usage. One that seems to be useful in conveying the idea behind the Factory method pattern is using the pattern to show the behaviour of pets <ref name="pets">http://javapapers.com/design-patterns/factory-method-pattern/ - 2012 </ref>. This site uses a mix of textual explanations and examples to explain the pattern. One advantage to using this site is that it is relatively short and includes a real world example. It also provides the code in a way that would make it simple to attempt to run it yourself and see how it works. A disadvantage for this resource is that it does not tell how to approach a "problem" or how to solve complex problem. This is useful to understand the basics for people who are new to design patterns and not useful for developers.
Although most examples for this pattern focus on other usages, it is possible to use the Factory method pattern with GUIs (Graphical User Interfaces) i.e creating Desktop applications. A useful example for understanding this usage can be found on OODesign.com <ref name="gui">http://www.oodesign.com/factory-method-pattern.html- ?</ref>. This site uses code and UML diagrams to explain the usage of Factory method when implementing GUIs. Along with code, there are sections which describe the UML diagrams and drawbacks. This site is useful because it offers code that can easily be tested and/or modified if needed to gain a better understanding. Another advantage is that there is not much that has to be read. A disadvantage is that if the code given is not similar to what you are trying to achieve it may be difficult to understand whether you need to be using the Factory method pattern for you particular GUI; outside sources may be needed for this understanding.
Summary
For Java and C# resources, we recommend:
References
<references />