Factory Method Pattern Example

🏭 Factory Method Pattern in Java — Step-by-Step Guide

The Factory Method Pattern is one of the key Creational Design Patterns in Java.
It provides an interface for creating objects, allowing subclasses or factory logic to decide which class to instantiate at runtime.

Rather than creating objects using the new keyword directly, the Factory hides the instantiation logic inside a dedicated class — improving flexibility, maintainability, and decoupling.

---

🎯 Real-World Analogy

Think of a person registration system.
Based on user input (M or F), we want to create a Male or Female object.

Instead of writing:

Person p = new Male();

everywhere in the code, we delegate that logic to a Factory.
So the client simply calls:

Person p = PersonFactory.getPerson("M");

and the factory takes care of the rest.

---

⚙️ Pattern Intent

• Define an interface for object creation.

• Let subclasses or logic decide which concrete class to instantiate.

• Decouple object creation from object usage.

---

🧩 Step 1: Create an Interface (Person.java)

package com.vinod.design.factory;

/**
 * Common interface for all Person types.
 */
public interface Person {
    void say();
}

---

🧩 Step 2: Create Concrete Implementations

👨 Male.java

package com.vinod.design.factory;

public class Male implements Person {
    @Override
    public void say() {
        System.out.println("I am male");
    }
}

👩 Female.java

package com.vinod.design.factory;

public class Female implements Person {
    @Override
    public void say() {
        System.out.println("I am female");
    }
}

---

🧩 Step 3: Create the Factory Class

package com.vinod.design.factory;

/**
 * Factory class that decides which Person object to create.
 */
public class PersonFactory {

    /**
     * Creates and returns a Person instance based on the input gender.
     *
     * @param gender "M" for Male, "F" for Female
     * @return Person instance or null if input is invalid
     */
    public Person getPerson(String gender) {
        if (gender == null) {
            return null;
        }

        if (gender.equalsIgnoreCase("M")) {
            return new Male();
        } else if (gender.equalsIgnoreCase("F")) {
            return new Female();
        }

        return null; // can also throw IllegalArgumentException
    }
}

---

🧩 Step 4: Test the Factory

package com.vinod.design.factory;

public class FactoryTest {

    public static void main(String[] args) {

        PersonFactory factory = new PersonFactory();

        // Create Male instance
        Person p1 = factory.getPerson("M");
        p1.say();

        // Create Female instance
        Person p2 = factory.getPerson("F");
        p2.say();

        // Invalid input test
        Person p3 = factory.getPerson("X");
        if (p3 == null) {
            System.out.println("Invalid gender input. No object created.");
        }
    }
}

---

🧾 Output

I am male
I am female
Invalid gender input. No object created.

---

🧠 How It Works (Step-by-Step)

Step	Action	Description
1️⃣	Client requests object creation	Calls factory.getPerson("M")
2️⃣	Factory checks input	Evaluates input value (“M” / “F”)
3️⃣	Factory creates instance	Uses new Male() or new Female()
4️⃣	Factory returns result	Returns Person reference to caller
5️⃣	Client uses interface	Calls say() without knowing the concrete type

---

🔍 Advantages of Factory Method Pattern

Benefit	Description
✅ Encapsulation	Object creation logic hidden from client
✅ Loose Coupling	Client depends only on interface, not implementation
✅ Extensibility	New types can be added without changing client code
✅ Reusability	Common creation logic centralized in the factory
✅ Simplicity	Cleaner and more readable code

---

⚠️ When to Use Factory Method

• When you don’t know the exact type of object to create at compile time.

• When you want to isolate the creation logic.

• When the object creation process is complex or conditional.

• When you want to return subclasses or implementations dynamically.

---

🧩 UML-Like Text Diagram

           +-------------------+
           |     Person        |  <-- Interface
           |-------------------|
           | + say()           |
           +---------+---------+
                     |
        +------------+------------+
        |                         |
 +-------------+           +-------------+
 |   Male      |           |   Female    |
 |-------------|           |-------------|
 | + say()     |           | + say()     |
 +-------------+           +-------------+
                     ^
                     |
             +----------------+
             | PersonFactory  |
             |----------------|
             | + getPerson()  |
             +----------------+
                     ^
                     |
             +----------------+
             |   FactoryTest  |
             +----------------+

---

🧭 Real-World Examples in Java

Use Case	Description
Calendar.getInstance()	Returns different Calendar subclasses based on locale/timezone
NumberFormat.getInstance()	Returns appropriate number format (e.g., for locale)
JDBC DriverManager.getConnection()	Creates a connection for a given database type
ExecutorService.newFixedThreadPool()	Factory method returning different thread pool types

---

✅ Summary

Concept	Description
Pattern Type	Creational
Purpose	Delegate object creation to a factory
Core Components	Interface, Concrete Classes, Factory Class
Key Benefit	Encapsulates creation logic, enhances flexibility
Real Example	PersonFactory creating Male or Female objects