You are here:
Home »
Software Design »
Design Patterns in Java: Simple Factory

Design Patterns in Java: Simple Factory

17th December 2017
/ Software Design
/ By Dragos Stanciu

In this blog post, I’ll briefly describe the simple factory pseudopattern.

This post is part of the Design Patterns in Java Series. Check out the full list of covered patterns there.

Why is the Simple Factory a Pseudopattern?

First of all, as I mentioned in the article on the factory method pattern, I use the prefix pseudo because the simple factory isn’t actually considered a pattern in the Gang of Four book.

Nevertheless, I’ve decided to write a blog post on this topic because I think the simple factory will give you a good intuition for understanding the proper factory patterns.

Many online resources portray the simple factory as the factory method pattern, which is wrong.

You can read more about the terminology on Wikipedia.

What is a Simple Factory?

The simple factory is essentially a class that, based on a given input, returns objects of different types.

In contrast to the factory method or the abstract factory, the simple factory is made up of just one concrete factory. This concrete factory doesn’t inherit from another abstraction layer.

Just to reiterate, the simple factory is not considered a genuine pattern. That being said, use this concept as a stepping stone to understanding the factory method and the abstract factory.

To illustrate this pattern, let’s consider we’re a company that builds computers. For the moment, we’re only producing laptops.

In the class diagram below, the concept of laptop is shown via the Laptop interface. We have two types of laptops which are represented by the NormalLaptop and GamingLaptop concrete classes that implement the Laptop interface.

The client code is using the LaptopFactory concrete factory class to create the objects it needs via the createLaptop() method.

Simple Factory Class Diagram

Pros

the same advantages mentioned for the factory method pattern such as encapsulating object creation apply.

Cons

if a new type of Laptop is added to the system, then we’d also need to change the logic, i.e. switch statement, in the createLaptop() method below. This can be avoided with the factory method pattern.

How Can You Implement the Simple Factory?

As usual, let’s implement in Java the design from the class diagram we saw in the previous section.

The Laptop interface would look something like this:

	public interface Laptop {
	void runTests();
	}

view raw Laptop.java hosted with ❤ by GitHub

The classes implementing the Laptop interface are as follows:

	public class NormalLaptop implements Laptop {

	@Override
	public void runTests() {
	System.out.println("Running tests on a NormalLaptop...");
	}
	}

view raw NormalLaptop.java hosted with ❤ by GitHub

	public class GamingLaptop implements Laptop {

	@Override
	public void runTests() {
	System.out.println("Running tests on a GamingLaptop...");
	}
	}

view raw GamingLaptop.java hosted with ❤ by GitHub

Next, the object creation is done in LaptopFactory based on information provided by the client code.

	public class LaptopFactory {

	// Objects are created here
	public Laptop createLaptop(String laptopType){
	if (laptopType == null) {
	return null;
	}

	switch (laptopType.toUpperCase()) {
	case "NormalLaptop":
	return new NormalLaptop();
	break;
	case "GamingLaptop":
	return new GamingLaptop();
	break;

	default:
	return null;
	}
	}
	}

view raw LaptopFactory.java hosted with ❤ by GitHub

Lastly, the client code receives an object depending on the requested type:

	public class Client {
	public static void main(String[] args) {
	LaptopFactory laptopFactory = new LaptopFactory();

	// Get object of type GamingLaptop and run tests.
	Laptop myLaptop = laptopFactory.createLaptop("GamingLaptop");

	myLaptop.runTests();
	}
	}

view raw Client.java hosted with ❤ by GitHub

The output would then be:

Running tests on a GamingLaptop...

view raw output.txt hosted with ❤ by GitHub

Summary

In conclusion, the two ideas you have to bear in mind are:

The simple factory is not a real pattern.
The simple factory is just the concrete factory, without the extra factory class abstraction found in either the factory method or abstract factory.

About the Author Dragos Stanciu

follow me on:

Like this article? Stay updated by subscribing to my weekly newsletter:

22 Nov, 2018

Design Patterns in Java: Observer Pattern

21 Nov, 2018

Design Patterns in Java: Strategy Pattern

26 Dec, 2017

Design Patterns in Java: Abstract Factory Pattern