Factory Design Pattern in Java

The Factory design pattern is a creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. The main idea behind this pattern is to create an object without exposing the creation logic to the client and referring to newly created objects through a common interface.

To implement the Factory Design Pattern in Java, follow these steps:

Define an interface or an abstract class for the products that the factory will create. This interface or abstract class should define the common methods that all products must have.
Create concrete classes that implement the interface or extend the abstract class. These concrete classes represent the different types of products that the factory can create.
Define a factory class that has a method for creating the products. This method should take an argument that specifies which product to create, and should return an instance of the appropriate concrete class.

Here’s an example implementation of the Factory Design Pattern in Java:

// Step 1: Define the product interface
public interface Product {
   void performAction();
}

// Step 2: Create concrete product classes
public class ConcreteProduct1 implements Product {
   public void performAction() {
      System.out.println("Performing action for ConcreteProduct1");
   }
}

public class ConcreteProduct2 implements Product {
   public void performAction() {
      System.out.println("Performing action for ConcreteProduct2");
   }
}

// Step 3: Define the factory class
public class ProductFactory {
   public Product createProduct(String type) {
      if(type.equals("Product1")) {
         return new ConcreteProduct1();
      } else if(type.equals("Product2")) {
         return new ConcreteProduct2();
      } else {
         throw new IllegalArgumentException("Invalid product type");
      }
   }
}

In this example, the Product interface defines the common performAction() method that all products must have. The ConcreteProduct1 and ConcreteProduct2 classes are concrete implementations of the Product interface.

The ProductFactory class has a createProduct() method that takes a type argument, which specifies which product to create. The method returns an instance of the appropriate concrete class based on the type argument.

To use the factory to create products, you can call the createProduct() method on an instance of the ProductFactory class:

ProductFactory factory = new ProductFactory();

Product product1 = factory.createProduct("Product1");
product1.performAction(); // Output: Performing action for ConcreteProduct1

Product product2 = factory.createProduct("Product2");
product2.performAction(); // Output: Performing action for ConcreteProduct2

This will create instances of the ConcreteProduct1 and ConcreteProduct2 classes based on the type argument passed to the createProduct() method, and return them to the caller.

The Factory design pattern in Java provides several benefits, including:

Encapsulation: The Factory pattern encapsulates the creation of objects in a separate class, separating object creation from the rest of the code. This promotes loose coupling and allows the code to be more modular and easier to maintain.
Abstraction: The Factory pattern provides an interface for creating objects, which allows for abstraction and simplifies the creation process. The client code only needs to specify the type of object to be created, without having to worry about the specific implementation details.
Flexibility: The Factory pattern allows for flexibility in object creation, as the factory class can decide which class to instantiate based on a set of criteria. This allows the code to be easily adapted to changing requirements, without requiring changes to the client code.
Reusability: The Factory pattern promotes code reuse by centralizing the object creation logic in a single class. This reduces duplication and improves maintainability, as changes to the creation process can be made in a single location.
Testing: The Factory pattern makes it easier to test code, as the creation of objects can be easily mocked or stubbed. This allows for more comprehensive testing of the client code, without having to worry about the specifics of object creation.

By using the Factory pattern in Java, developers can encapsulate object creation logic in a separate class, making it easier to maintain and update. It also provides a simple way to create objects without exposing the creation logic to the client.

Share on Facebook

Save