Definition

The Factory Method pattern is a creational design pattern that defines an interface for creating objects, but allows subclasses to alter the type of objects that will be created. It encapsulates the object creation logic in a separate method, allowing subclasses to provide their own implementations of the factory method to create specific types of objects.

Problem that the Pattern Solves

In scenarios where the object creation process is complex, subject to variation, or requires customization based on specific conditions, directly instantiating objects using constructors can lead to tight coupling and reduced flexibility. The Factory Method pattern addresses these challenges by delegating the responsibility of object creation to subclasses, promoting loose coupling, and enhancing extensibility.

Key Components

1. Product Interface: Defines the common interface for all products.

2. Concrete Products: Implement the product interface, representing different types of products.

3. Factory Interface: Declares the factory method to create products. It can also provide default implementations for the factory method.

4. Concrete Factories: Implement the factory method to create specific types of products.

Code

// Step 1: Product Interface
interface Product {
    void display();
}

// Step 2: Concrete Products
class Book implements Product {
    @Override
    public void display() {
        System.out.println("Displaying Book");
    }
}

class Pencil implements Product {
    @Override
    public void display() {
        System.out.println("Displaying Pencil");
    }
}

// Step 3: Factory Interface
interface ProductFactory {
    Product create();
}

// Step 4: Concrete Factories
class BookFactory implements ProductFactory {
    @Override
    public Product create() {
        return new Book();
    }
}

class PencilFactory implements ProductFactory {
    @Override
    public Product create() {
        return new Pencil();
    }
}

// Client Code
public class Client {
    public static void main(String[] args) {
        ProductFactory bookFactory = new BookFactory();
        Product book = bookFactory.create();
        book.display();

        ProductFactory pencilFactory = new PencilFactory();
        Product pencil = pencilFactory.create();
        pencil.display();
    }
}

Code Explanation

• Product Interface: The Product interface declares a method display() that all concrete products must implement, ensuring a common interface for all products.

• Concrete Products: The Book and Pencil classes implement the Product interface, providing specific implementations for different types of products.

• Factory Interface: The ProductFactory interface declares the factory method create() to create products. It can also provide default implementations or common logic for the factory method.

• Concrete Factories: The BookFactory and PencilFactory classes implement the ProductFactory interface, providing specific implementations for the factory method to create Book and Pencil instances, respectively.

Advantages

• Encapsulation: Encapsulates the object creation logic within separate creator classes, promoting loose coupling and encapsulation of object creation details.

• Extensibility: Facilitates easy extension and customization of the object creation process by allowing subclasses to provide their own implementations of the factory method.

• Flexibility: Enables dynamic object creation based on runtime conditions or configurations, enhancing flexibility in object-oriented systems.

• Reusability: Promotes code reusability by allowing the reuse of existing creator and product implementations across different parts of the application.

Disadvantages

• Complexity: Introduces additional complexity, especially when dealing with a large number of product types or variations, leading to increased class hierarchies and potential maintenance challenges.

• Potential Tight Coupling: While promoting loose coupling between clients and factories, the Factory Method pattern can lead to tight coupling between the factory and product classes.

• Overhead: In scenarios with simple object creation requirements or fewer variations, the Factory Method pattern might introduce unnecessary overhead and complexity.

When to Use

• You need to encapsulate the object creation logic and provide a flexible mechanism for dynamic object creation.

• The object creation process is subject to variation or customization based on specific conditions or configurations.

• You want to promote loose coupling between clients and products by abstracting the object creation process.

Best Practices

• Design the factory method and product interfaces with a focus on clarity, simplicity, and adherence to the Single Responsibility Principle.

• Consider defining default or common implementations in the factory interface to avoid duplication and promote consistency.

• Use meaningful names for factory and product classes, adhering to consistent naming conventions to enhance code clarity and maintainability.

By understanding the Factory Method design pattern's principles, advantages, and considerations, developers can effectively utilize it to encapsulate object creation logic, promote loose coupling, and enhance extensibility and flexibility in object-oriented systems.