The Factory Method design pattern is a fundamental tool in the world of software engineering, particularly in object-oriented design. It falls under the creational design patterns category and is highly valued for its ability to create objects without specifying the exact class of object to be created.

Table of contents

Sections

Overview

The primary goal of the Factory Method pattern is to define an interface for creating an object, but let the subclasses alter the type of objects that will be created. This way, it allows a class to delegate the responsibility of instantiating its instances to its subclasses.

In simpler terms, it creates an instance of several derived classes based on provided data or conditions, without the client needing to know the actual class of the object being created.

Benefits of the Factory Method Pattern

Abstraction and Encapsulation:

The Factory Method pattern encapsulates the creation logic from the client, providing an abstract interface for creating objects. This promotes a clean separation of concerns.

Flexibility and Extensibility:

It allows for easy extension of the creation process, enabling new types of objects to be added without modifying existing client code.

Code Reusability:

The pattern promotes reusability of code by allowing common creation logic to be centralized within the Factory Method.

The pattern ensures that there’s only one instance of the class throughout the application.

Global Access:

The singleton pattern provides a global point of access to that single instance.

How the Factory Method Works

Imagine a scenario where we need to create instances of different subclass types based on specific criteria, but the client doesn’t need to know the exact implementation. This is where the Factory Method pattern shines.

In the provided Java example, we delve into a fictional scenario involving different shapes of foods. The client desires a particular food shape, but it doesn’t want to handle the intricacies of creating those shapes. The Factory Method pattern steps in to abstract this process.

Implementation Steps

Define the Interface:

Start by creating an interface that declares the common functionality that will be implemented by subclasses.

Interface

public interface Shape {
    public String getShape();
}

Implement Subclasses:

Create various subclasses implementing the interface, each providing its own implementation of the functionality.

Pizza Class

public class Pizza implements Shape {

    @Override
    public String getShape() {
        return "Round";
    }
}

Burrito Class

public class Burrito implements Shape {

    @Override
    public String getShape() {
        return "Cylinder";
    }
}

Create the Factory Class:

Develop a factory class responsible for instantiating the appropriate subclass based on specified criteria.

Factory Class

public class ShapeFactory {
    public Shape getFood(String type) {
        if (type == null) {
            return null;
        }
        switch (type) {
            case "Round": return new Pizza();
            case "Cylinder": return new Burrito();
            default: throw new IllegalArgumentException("Unknown Shape");
        }
    }
}

Utilize the Factory Method:

The client uses the factory method to obtain instances of the desired subclass without needing to know the actual implementation details.

Client Class

    ShapeFactory shapeFactory = new ShapeFactory();

    Shape roundFood = shapeFactory.getFood("Round");
    Shape cylinderFood = shapeFactory.getFood("Cylinder");

    @Test
    public void factoryMethodTest() {
        assertEquals("Round", roundFood.getShape());
        assertEquals("Cylinder", cylinderFood.getShape());
    }

Conclusion

The Factory Method design pattern is a powerful tool that promotes clean code architecture and efficient object creation. By providing an abstract interface for creating objects, it encapsulates the creation process, allowing subclasses to alter the type of objects created.

In this blog post, we explored the essential concepts of the Factory Method pattern and its advantages, including abstraction, flexibility, and code reusability. We also went through a simple Java example, illustrating how this pattern can be applied to create instances based on specific criteria while hiding the implementation details from the client.

By adopting the Factory Method design pattern, software developers can enhance code maintainability and scalability. It’s a valuable approach in situations where multiple related objects need to be created, enabling easy extension and customization without modifying the existing codebase.

Incorporating the Factory Method pattern into your software design toolkit empowers you to build robust, adaptable systems that can evolve seamlessly to meet changing requirements and future expansions.

Happy coding and may your designs be as flexible as the Factory Method itself!