Factory Design Pattern In Java Example

Let's talk about the Factory Design Pattern stands as one of the most fundamental and widely used creational patterns in software engineering. At its core, it provides an interface for creating objects in a superclass but allows subclasses to alter the type of objects that will be created. This approach decouples the client code from the concrete implementation classes, fostering a system that is significantly easier to extend, maintain, and test. Because of that, instead of calling a constructor directly using the new keyword, the client code delegates the instantiation logic to a dedicated factory method or class. For Java developers aiming to write clean, scalable architecture, mastering this pattern is not optional—it is essential.

Understanding the Core Problem

Before diving into the solution, it helps to visualize the problem the pattern solves. Imagine you are building a logistics management application. Initially, the application only handles road transport, so you create a Truck class and instantiate it directly throughout your codebase: Transport transport = new Truck(); Worth keeping that in mind..

Worth pausing on this one.

Months later, business requirements expand. The company now offers sea and air shipping. You create Ship and Plane classes.

if (type.equals("road")) return new Truck();
else if (type.equals("sea")) return new Ship();
else if (type.equals("air")) return new Plane();

This approach violates the Open/Closed Principle (classes should be open for extension but closed for modification). Every time a new transport type is added, you must modify the existing conditional blocks, increasing the risk of introducing bugs. Adding to this, the client code becomes tightly coupled to concrete classes (Truck, Ship, Plane), making unit testing difficult because you cannot easily swap a real implementation for a mock object.

The Factory Pattern eliminates this tight coupling by encapsulating the object creation logic.

The Factory Method Pattern: Structure and Implementation

The classic Factory Method pattern (defined by the Gang of Four) relies on inheritance. It defines an abstract method for creating an object in a base class (often an interface or abstract class) and lets subclasses decide which class to instantiate.

Key Components

1. Product Interface: Defines the common operations for all objects the factory can create.
2. Concrete Products: Implement the Product interface (e.g., Truck, Ship).
3. Creator (Abstract Class/Interface): Declares the factory method that returns a Product object.
4. Concrete Creators: Override the factory method to return a specific Concrete Product instance.

Java Code Example: Logistics Framework

Let’s translate the logistics scenario into a dependable Java implementation.

1. The Product Interface

public interface Transport {
    void deliver(String destination);
}

2. Concrete Products

public class Truck implements Transport {
    @Override
    public void deliver(String destination) {
        System.out.println("Delivering via road to " + destination + " in a Truck.");
    }
}

public class Ship implements Transport {
    @Override
    public void deliver(String destination) {
        System.out.println("Delivering via sea to " + destination + " on a Cargo Ship.

public class Plane implements Transport {
    @Override
    public void deliver(String destination) {
        System.That's why out. println("Delivering via air to " + destination + " by Plane.

**3. The Creator Hierarchy**

The abstract `Logistics` class contains the core business logic (`planDelivery`) but delegates the creation of the `Transport` object to the factory method `createTransport()`.

```java
public abstract class Logistics {
    // The Factory Method
    public abstract Transport createTransport();

    // Business logic that relies on the factory method
    public void planDelivery(String destination) {
        Transport transport = createTransport(); // Delegation happens here
        System.out.println("Logistics: Planning delivery...");
        transport.

**4. Concrete Creators**

Each subclass implements the factory method to return a specific product.

```java
public class RoadLogistics extends Logistics {
    @Override
    public Transport createTransport() {
        return new Truck();
    }
}

public class SeaLogistics extends Logistics {
    @Override
    public Transport createTransport() {
        return new Ship();
    }
}

public class AirLogistics extends Logistics {
    @Override
    public Transport createTransport() {
        return new Plane();
    }
}

5. Client Code

The client interacts only with the abstract Logistics and Transport types. It remains completely unaware of the concrete classes (Truck, Ship, Plane) It's one of those things that adds up..

public class Application {
    private Logistics logistics;

    // Configuration logic (could come from config file, env var, or UI)
    public void initialize(String transportType) {
        switch (transportType.toLowerCase()) {
            case "road":
                logistics = new RoadLogistics();
                break;
            case "sea":
                logistics = new SeaLogistics();
                break;
            case "air":
                logistics = new AirLogistics();
                break;
            default:
                throw new IllegalArgumentException("Unknown transport type: " + transportType);
        }
    }

Some disagree here. Fair enough.

    public void executeDelivery(String destination) {
        logistics.planDelivery(destination);
    }

    public static void main(String[] args) {
        Application app = new Application();
        app.initialize("sea"); // Switch to "air" or "road" without changing business logic
        app.executeDelivery("New York");
    }
}

Output:

Logistics: Planning delivery...
Delivering via sea to New York on a Cargo Ship.

The Simple Factory (Static Factory) Variation

While the Factory Method pattern uses inheritance, a very common variation in Java is the Simple Factory (often called Static Factory Method). Practically speaking, this is not a formal GoF pattern but an idiom where a single class encapsulates the creation logic using a static method. It is simpler but less extensible because adding a new product requires modifying the factory class itself (violating Open/Closed Principle slightly), though it avoids the need for a parallel hierarchy of creators And it works..

Example: ShapeFactory

// Product Interface
interface Shape {
    void draw();
}

// Concrete Products
class Circle implements Shape {
    @Override public void draw() { System.out.println("Drawing a Circle"); }
}

class Rectangle implements Shape {
    @Override public void draw() { System.out.println("Drawing a Rectangle"); }
}

class Square implements Shape {
    @Override public void draw() { System.out.println("Drawing a Square"); }
}

// Simple Factory
class ShapeFactory {
    // Static factory method
    public static Shape getShape(String shapeType) {
        if (shapeType == null) return null;
        
        switch (shapeType.toUpperCase()) {
            case "CIRCLE": return new Circle();
            case "RECTANGLE": return new Rectangle();
            case "SQUARE": return new Square();
            default: throw new IllegalArgumentException("Unknown shape: " + shapeType);
        }
    }
}

// Client
public class FactoryPatternDemo {
    public static void main(String[] args) {
        Shape shape1 = ShapeFactory.getShape("CIRCLE");
        shape1.draw();

        Shape shape2 = ShapeFactory.getShape("RECTANGLE");
        shape2.draw();
    }
}

This approach is perfectly valid for scenarios where the set of products is stable and unlikely to change frequently, or when the factory logic is purely utility-based (like java.util.Because of that, collections. synchronizedList()) Most people skip this — try not to..

Real-World Usage in the Java Ecosystem

The Factory Pattern is pervasive in the Java Development Kit (JDK) and major frameworks like Spring. Recognizing these implementations helps solidify the concept Easy to understand, harder to ignore..

1. java.util.Calendar.getInstance(): Returns a Calendar instance appropriate for the default locale (e.g., GregorianCalendar, BuddhistCalendar, JapaneseImperialCalendar). The client doesn't know or care which concrete subclass is returned.
2. java.util.Collections: Methods like synchronizedList(List), `

Methods like synchronizedList(List), unmodifiableSet(Set), and emptyMap() return instances of specialized collection classes (e.g.That's why , Collections. SynchronizedList, Collections.And unmodifiableSet, Collections. Here's the thing — emptyMap) without exposing their concrete types. This allows the JDK to optimize implementations (like using a singleton for empty collections) while maintaining a consistent interface for clients.

Beyond the JDK, the pattern is foundational in enterprise frameworks. In Spring Framework, the core BeanFactory and ApplicationContext interfaces act as sophisticated factories. getBean("myService")), and Spring handles instantiation, dependency injection, and lifecycle management—often leveraging factory methods (@Beanannotated methods) orFactoryBean implementations for complex creation logic. Day to day, clients request beans by name or type (context. Similarly, Java EE's dependency injection (@Inject) and modern frameworks like Micronaut or Quarkus rely on factory principles to manage object creation decoupled from usage Worth knowing..

When to Choose Which Variant

• Simple Factory (Static Method): Ideal for utility-like creation with a stable, limited set of products (e.g., java.util.Collections, java.util.Objects.requireNonNull()). Avoid if product types change frequently.
• Factory Method: Use when a class cannot anticipate the exact type of object it must create, or when subclasses should decide which class to instantiate (e.g., framework extensibility points like javax.servlet.ServletContext.getRequestDispatcher()).
• Abstract Factory: Optimal when families of related objects must be created together (e.g., GUI toolkits creating buttons/textfields for Windows/Mac/Linux, or database vendors creating Connections/Statements/ResultSets).

Conclusion

The Factory Pattern, in its various forms, remains a cornerstone of dependable Java design by encapsulating object creation logic. It promotes loose coupling, enhances code readability, and centralizes complex instantiation logic—whether it's selecting a locale-specific Calendar, obtaining a thread-safe collection view, or configuring a Spring bean. While the Simple Factory offers pragmatic utility for stable hierarchies, the true power of the pattern lies in its ability to adhere to the Open/Closed Principle through inheritance (Factory Method) or composition (Abstract Factory), allowing systems to evolve without modifying existing client code. Recognizing these patterns in JDK and framework code not only aids understanding but also guides developers to apply them judiciously, balancing simplicity with the need for future extensibility. In the long run, whether through a static utility method or a sophisticated DI container, the factory mindset—delegating creation responsibility—is essential for building maintainable, flexible Java applications.