Understanding the Factory Method in Java: A Comprehensive Guide

The factory method pattern is a design pattern that falls under the category of creational patterns. It is particularly useful in Java, where the goal is to encapsulate object creation logic, providing more control over the instantiation process and enabling the system to be more flexible and decoupled.

What is the Factory Method Pattern in Java?

The factory method pattern is a design pattern that allows a method to return an object of a specific type or a related type. In Java, it is commonly used to create objects of a type that needs to be determined at runtime based on specific logic. This pattern is particularly useful when you want to simplify object creation and encapsulate the implementation details.

This pattern is often confused with the abstract factory pattern, which is a more complex creational pattern. The factory method pattern provides a more basic level of abstraction, while the abstract factory pattern provides a more generalized abstraction to create families of related objects.

Key Concepts of the Factory Method Pattern

The factory method pattern is characterized by the following:

A specific method is used to create objects instead of using the constructor directly. The creation logic can be moved to the factory class, making the client code more flexible and easier to extend. Logic can be embedded within the factory method to determine the appropriate object type to create based on specific conditions or configurations.

This pattern adheres to the principles of the Open/Closed Principle, meaning that the system is open for extension but closed for modification. This allows the creation process to remain intact while new concrete classes can be added without altering the existing code.

How is the Factory Method Pattern Useful?

The primary advantages of the factory method pattern are:

Loose Coupling: The client code only interacts with the factory interface or abstract class, which decouples it from the specific concrete implementations. This improves the flexibility of the system, making it easier to modify or extend the system without affecting the client code. Flexibility: By encapsulating the creation logic in the factory method, you can change the creation process or add new concrete classes easily without modifying the client code. Decoupling: It reduces the direct dependence of the client on specific concrete implementations, thus making the system more modular and easier to maintain.

Example Implementation of the Factory Method Pattern in Java

Let's dive into an example to better understand how the factory method pattern can be implemented in Java. We will create a scenario where we need to create different types of plans, such as domestic and commercial plans, and a factory to create and return these objects based on specific criteria.

First, we define a base class Plan with a method to calculate the bill:

// Step 1: Create a Plan abstract classpackage ;abstract class Plan {    protected double rate;    abstract void getRate();    public void calculateBill(int units) {        (units * rate);    }}

Next, we create concrete classes that extend the Plan class:

// Step 2: Create the concrete classes that extends Plan abstract classpackage ;public class DomesticPlan extends Plan {    @Override    public void getRate() {        rate  3.50;        }}package ;public class CommercialPlan extends Plan {    void getRate() {        rate  7.5;    }}

Then, we create a factory class that returns instances of the appropriate concrete plan based on the given plan type:

// Step 3: Create a GetPlanFactory to generate object of concrete classes based on given informationpackage ;public class GetPlanFactory {    // use getPlan method to get object of type Plan    public Plan getPlan(String planType) {        if (planType  null) {            return null;        }        if (planType.equalsIgnoreCase("DOMESTIC_PLAN")) {            return new DomesticPlan();        } else if (planType.equalsIgnoreCase("COMMERCIAL_PLAN")) {            return new CommercialPlan();        }        return null;    }}

Finally, we can use the factory to generate and use the appropriate plan:

// Step 4: Generate Bill by using the GetPlanFactory to get the object of concrete classespackage ;import ;import ;public class GenerateBill {    public static void main(String[] args) throws IOException {        try {            GetPlanFactory planFactory  new GetPlanFactory();            Scanner sc  new Scanner();            String planName  ();            int units  ();            Plan p  (planName);            // call getRate method and calculateBill method of DomesticPlan.            ();            (units);        } catch (Exception e) {            (());        } finally {            // resource management        }    }}

This example demonstrates how the factory method pattern can be used to create objects based on specific criteria, encapsulating the creation logic in the factory, and providing loose coupling between the client code and the concrete implementations.

Conclusion

The factory method pattern is a powerful design pattern that simplifies object creation by encapsulating it in a factory method. This pattern enhances the flexibility and maintainability of Java applications, making them more adaptable to changing requirements and easy to extend without modifying the client code. By understanding and applying this pattern, developers can write more robust, modular, and maintainable Java applications.

References

Factory method pattern - Wikipedia Manish K Singh - What is GOF Design Patterns in Java