1.2 Factory Method - Design Pattern: A Practical Guide

Factory Method Design Pattern: A Comprehensive Guide

The Factory Method is a popular creational design pattern that helps in creating objects without specifying the exact class of the object that will be created. This pattern is widely used when a class cannot anticipate the type of objects it needs to create, or when the creation process needs to be abstracted and handled in different ways by subclasses.

In this blog, we'll break down the Factory Method Pattern, explore how it works, and show you an example of how it can be applied in Java to create notifications (such as email and SMS).

What is the Factory Method Pattern?

The Factory Method pattern defines a method for creating objects in a superclass but allows subclasses to alter the type of objects that will be created. Instead of directly instantiating an object using a constructor, the Factory Method abstracts the creation process, which allows you to delegate the object creation to subclasses.

This pattern is especially useful when you want to allow the system to create objects dynamically or in a modular fashion, without hardcoding their creation in the main code.

Key Benefits of the Factory Method Pattern

• Flexibility: You can change the type of object that is created without modifying the code that uses the object.

• Loose Coupling: The client code does not need to know about the concrete classes it’s working with. It relies on the factory method to get the right object.

• Maintainability: It simplifies code maintenance by centralizing the object creation logic and separating it from the core application logic.

Breaking Down the Example: Notifications System

Let’s imagine a scenario where you need to send notifications in different formats, such as email and SMS. By using the Factory Method pattern, we can define a common interface for all types of notifications and then provide specific factories for creating email and SMS notifications.

Here’s how we implement this:

Java Code Example: Factory Method for Sending Notifications

// Notification interface
interface Notification {
    void notifyUser();
}

// Concrete EmailNotification class
class EmailNotification implements Notification {
    @Override
    public void notifyUser() {
        System.out.println("Sending an Email notification");
    }
}

// Concrete SMSNotification class
class SMSNotification implements Notification {
    @Override
    public void notifyUser() {
        System.out.println("Sending an SMS notification");
    }
}

// NotificationFactory interface
interface NotificationFactory {
    Notification createNotification();
}

// EmailNotificationFactory class
class EmailNotificationFactory implements NotificationFactory {
    @Override
    public Notification createNotification() {
        return new EmailNotification();
    }
}

// SMSNotificationFactory class
class SMSNotificationFactory implements NotificationFactory {
    @Override
    public Notification createNotification() {
        return new SMSNotification();
    }
}

// Main class to demonstrate the Factory Method Pattern
public class Main {
    public static void main(String[] args) {
        // Factory for creating email notifications
        NotificationFactory emailFactory = new EmailNotificationFactory();
        Notification emailNotification = emailFactory.createNotification();
        emailNotification.notifyUser();  // Output: Sending an Email notification

        // Factory for creating SMS notifications
        NotificationFactory smsFactory = new SMSNotificationFactory();
        Notification smsNotification = smsFactory.createNotification();
        smsNotification.notifyUser();  // Output: Sending an SMS notification
    }
}

Explanation of the Code:

1. Notification Interface:

   • The Notification interface defines a notifyUser() method that all concrete notification types (such as email and SMS) will implement.

2. Concrete Classes:

   • EmailNotification and SMSNotification are concrete implementations of the Notification interface. Each class defines how the notification is sent, either via email or SMS.

3. Factory Interface:

   • NotificationFactory is an interface that declares the createNotification() method. This method is used by the factories to create specific notification objects.

4. Concrete Factories:

   • EmailNotificationFactory and SMSNotificationFactory are the concrete factories that implement the NotificationFactory interface and return the appropriate notification type (EmailNotification or SMSNotification).

5. Main Class:

   • The Main class demonstrates how to use the Factory Method pattern to create and send notifications. It creates the respective factory (EmailNotificationFactory or SMSNotificationFactory), uses it to create a notification, and then calls the notifyUser() method.

Output:

Sending an Email notification
Sending an SMS notification

When to Use the Factory Method Pattern?

The Factory Method pattern is particularly useful when:

• You need to instantiate objects of different types at runtime based on certain conditions or configurations.

• You want to isolate the object creation logic from the client code, making it easier to modify or extend in the future.

• Your application needs to support multiple product variations without altering the client code.

• You need to provide a controlled way of object creation, especially when dealing with complex creation logic.

Conclusion

The Factory Method pattern is a powerful tool for improving flexibility, reducing coupling, and making your code more scalable. By abstracting object creation, it enables you to easily introduce new types of objects or change the object creation logic without modifying the client code.

In the example above, we used the Factory Method to create different types of notifications (email and SMS) in a modular and extensible way. This approach ensures that adding a new notification type in the future (like push notifications) won't require changes to the existing client code, thus promoting clean, maintainable design.

By incorporating the Factory Method into your design strategy, you can create systems that are adaptable and easier to manage as they grow.