Java Design Pattern: Factory Method Pattern



Going on with the speach about design patterns started previously, we are going to talk about another pattern often used: the Factory Method Pattern.

The GoF (Gang of Four Design Patterns) defines it in this way:

It defines an interface to create objects, but leaves to the subclasses the decision about the type of the class to instantiate.

Starting from the definition, we can see that the problem regarding the inheritance among classes discussed for the Singleton Pattern is no longer present. In fact, we decide to use the Factory Method Pattern when we are not able to know the exact type of object to be created beforehand or when we want to delegate the task of creating objects to other entities

In the majority of the books about this topic, the pattern is represented using an UML diagram like the one below:

Factory Method Pattern

Foundamental patterns's entities

  • Creator:  it has the duty of declaring the Factory that will take care of returning the correct object;
  • ConcreteCreator: it makes the override of the Factory's method in order to return the correct implementation of the object;
  • Product: it defines the interface of the object that Factory has to return;
  • ConcreteProduct:it implements the object basing on Product;

The first observation, even if trivial, is that the implementation is definitely more complicated than the almost elementary one of the Singleton.

Some examples

Starting from an elementary example, let's define a CatFactory:

//Product
interface Cat{
public void speak ();
}

Every returned element from the factory has to implement this interface.

Let's create the concrete classes:

//ConcreteProduct
class Abissinian implements Cat{
public void speak(){
System.out.println("Abissinian");
}
}
class AmericanCurl implements Cat{
public void speak(){
System.out.println("American Curl");
}
}
class Asian implements Cat{
public void speak(){
System.out.println("Asian");
}
}

I decided to implement every class as non-public, assuming its placement in the same file. In fact, as we know, Java prohibits more than one public class in the same file, since the file must have the same name as the public class.

The foundamental concept of this pattern is the fact that every concrete class is a derivative of a basic type. In this case, every class implements Cat.

The Factory Class

The element to which the creation of objects is entrusted is precisely the so-called Factory class, which will have a static method with this functionality inside.

Let's see how this class could be implemented:

public class Factory{
public static Cat generateCat(String criteria){
if(criteria.equals("Abissino"))
return new Abissino();
if(criteria.equals("Curl"))
return new AmericanCurl();
if(criteria.equals("Asian"))
return new Asian();
return null;
}
}

We can notice that the code of the Factory class is quite easy, because it accepts only three strings. In a hypothetical real situation, the code would be longher and more complex, but this one is sufficient to give an idea of how the pattern works.

The Factory Method has different advantages and disadvantages, such as:

  • it represents a link to the subclasses: through the creator it is possible to dynamically choose which concrete class to use without any impact on the use of the end user;
  • it links class hierarchies in parallel: the ConcreteCreator can connect to the ConcreteProduct and generate a parallel link between different hierarchies;

Why use the Factory Method Pattern?

As I told before, there are different situations where we can't know before what the concrete type of the objects that will be instanciated. But the problem is much more bigger.

We could run into cases where we know the exact type of objects, but the latter may change in the future. So the client is free from the burden of knowing what kind of objects has to instanciate and the pattern returns an abstract object which is then realized through the classes inherited from the abstract entity. The client often guides the creation of the object, as in the example shown above, but ignores the details of its construction.

The Iterator pattern

It could sound strange, but the Iterator pattern can be assimilated to the Factory Method family. In fact Iterator allows us to access sequentially to the elements of a list, relieving the caller of the need to know what the instantiated classes are.

Iterator is an interface that exposes three methods:

  • boolean hasNext() that returns true if another iteration is possible;
  • Object next() which returns the item following the current one;
  • void remove() that removes the current element from the list;

Let's look at an example:

import java.io.*; 
import java.util.*; 
class Test { 
public static void main(String[] args) 
{ 
ArrayList
 list = new ArrayList
(); 
list.add("1"); 
list.add("2"); 
list.add("3"); 
list.add("4"); 
list.add("5"); 
// Iterator to scan the list  
Iterator iterator = list.iterator(); 
System.out.println("List elements : "); 
while (iterator.hasNext()) 
System.out.print(iterator.next() + " "); 
System.out.println(); 
} 
} 


We will obtain as output:

List elements : A B C D E

Java makes available a class called ListIterator that allows to scan objects collections in both directions, from the head to the tail and from the tail to the head.

Summing up

We use the Factory Method Pattern when:

  • A class can not know in advance the exact type of the object to create;
  • The class knows the exact type of objects, but it needs to delegate to another extern entity their creation;

Participants:

  • Product:  is the interface of the object created by the Factory Method;
  • ConcreteProduct: implements Product;
  • Creator: declares the Factory method and returns a Product object;
  • ConcreteCreator: specifies the Factory Method and returns the correct instance;

So:

  • The code has a higher flexibility level;
  • A wrong usage can lead to the generation of too much classes;

Focusing on some implementation details:

  • Creator can be concrete or abstract, and it can create a default version of the Factory Method;
  • A Factory can build objects of different types using if-then-else constructs;

Typically the Factory Method Pattern is used to create Logger and other softwares of this kind. wink

 
by Alessio Mungelli Date: 05-11-2019 java jdk jre explanation tutorial design pattern designpattern factory method factorymethod source code hits : 1933  
 
Alessio Mungelli

Alessio Mungelli

Computer Science student at UniTo (University of Turin), Network specializtion, blogger and writer. I am a kind of expert in Java desktop developement with interests in AI and web developement. Unix lover (but not Windows hater). I am interested in Linux scripting. I am very inquisitive and I love learning new stuffs.

 
 
 

Related Posts

Difference between arrow and normal functions in JavaScript

In this tutorial we are going to see how arrow functions differ from normal JavaScript functions. We will also see when you should use one and when you should use…

JavaScript Arrow functions: What they are and how to use them

In this article we are going to see what they are and how to use JavaScript Arrow Functions, a new feature introduced with the ES6 standard (ECMAScript 6). What are Arrow…

How to insert an element into an array with JavaScript

In this brief tutorial you will learn how to insert one or more elements into an array with JavaScript. For this we will use the splice function. The splice function will not…

What is the difference between primitives types and objects in JavaScript?

In this short tutorial we are going to look at the differences between primitive types and objects in JavaScript. To start with, we're going to look at what primitive types…

How to get DOM elements with JavaScript

When you access any element of the DOM, it is usual to save it in a variable. This is something that at first might seem very simple, but if you…

How to reverse an array in JavaScript

In this tutorial we are going to see how you can change the order of the elements of an array so that they are inverted. You could use a loop…

How synchronize the scroll of two divs with JavaScript

In case you have two divs of different sizes you may sometimes want to scroll both at the same time but at different speeds depending on their size. For example,…

How to use the codePointAt method in JavaScript

The JavaScript codePointAt method has more or less the same function as the charCodeAt method, used to get the 16-bit Unicode representation of the character at a certain position in…

How to check if a value is a number in JavaScript

In this short tutorial we are going to look at the various methods that exist to find out if a value is a number in JavaScript.   1. Using the isNaN() function   One…

How to use the charCodeAt method in JavaScript

The charCodeAt method is accepted by strings in JavaScript, returning the 16-bit Unicode code of the character at the position we pass as a parameter to the method. The charCodeAt method…

How to use the charAt method in JavaScript

The charAt method is accepted by strings in JavaScript, returning the position of the character passed as a parameter within the string. If the string contains multiple occurrences of the character…

Strings in JavaScript: What they are and how to use them

In this tutorial we are going to explain what strings are and how they are used in JavaScript. The tutorial is intended for people who are learning to program in…

We use our own and third-party cookies to improve our services, compile statistical information and analyze your browsing habits. This allows us to personalize the content we offer and to show you advertisements related to your preferences. By clicking "Accept all" you agree to the storage of cookies on your device to improve website navigation, analyse traffic and assist our marketing activities. You can also select "System Cookies Only" to accept only the cookies required for the website to function, or you can select the cookies you wish to activate by clicking on "settings".

Accept All Only sistem cookies Configuration