🏭 Factory Design Pattern in Java

The Factory Design Pattern is a creational design pattern used to create objects without exposing the creation logic to the client.

Instead of using new keyword directly, we delegate the object creation to a factory method.

🎯 Real-Life Analogy

🧃 Imagine ordering a drink at a juice shop.

You don't care how the juice is made – you just say "Give me an Orange Juice", and the shop handles the rest.

Similarly, with the Factory Pattern, the factory class creates the object based on your input.

🔧 When to Use It?

• When the object creation logic is complex or depends on conditions.
• When you want to centralize creation logic.
• When you need loose coupling between classes.

🔥 Basic Example – Shape Factory

🔸 Step 1: Create a common interface

interface Shape {
    void draw();
}

🔸 Step 2: Implement different shapes

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

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

🔸 Step 3: Create a Factory class

class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) return null;

        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }

        return null;
    }
}

🔸 Step 4: Use Factory in Main Class

public class Main {
    public static void main(String[] args) {
        ShapeFactory factory = new ShapeFactory();

        Shape shape1 = factory.getShape("CIRCLE");
        shape1.draw();

        Shape shape2 = factory.getShape("SQUARE");
        shape2.draw();
    }
}

✅ Output

📌 Key Concepts

| Concept | Description | | --------------------- | ------------------------------------------------- | | Loose Coupling | Client doesn’t care how objects are created | | Reusability | Easy to manage and extend object creation | | Encapsulation | Hides object instantiation logic | | Open/Closed Principle | Easy to add new shapes without modifying old code |

🧠 Real-World Use Case: Notification Service

Suppose your app supports notifications via Email and SMS. The client should just say “Send Notification” — the factory decides how.

🔸 Step 1: Notification Interface

interface Notification {
    void notifyUser();
}

🔸 Step 2: Implementations

class EmailNotification implements Notification {
    public void notifyUser() {
        System.out.println("Sending Email Notification");
    }
}

class SMSNotification implements Notification {
    public void notifyUser() {
        System.out.println("Sending SMS Notification");
    }
}

🔸 Step 3: Factory Class

class NotificationFactory {
    public Notification createNotification(String type) {
        if (type == null || type.isEmpty()) return null;

        if (type.equalsIgnoreCase("EMAIL")) {
            return new EmailNotification();
        } else if (type.equalsIgnoreCase("SMS")) {
            return new SMSNotification();
        }

        return null;
    }
}

🔸 Step 4: Main Class

public class NotificationService {
    public static void main(String[] args) {
        NotificationFactory factory = new NotificationFactory();

        Notification email = factory.createNotification("EMAIL");
        email.notifyUser();

        Notification sms = factory.createNotification("SMS");
        sms.notifyUser();
    }
}

✅ Output

🚫 Anti-Patterns to Avoid

• ❌ Huge if-else chains in factory → use enum or config to clean it later.
• ❌ Mixing business logic inside factory → keep factory focused on object creation only.

🧠 Interview Q&A

Q: What pattern category does Factory belong to? A: Creational

Q: What's the difference between Factory and Abstract Factory? A:

• Factory → returns one family/type of object.
• Abstract Factory → returns related objects from multiple factories.

Q: Why not just use new? A: Because new tightly couples the client with the implementation. Factory gives you flexibility and control.

📚 Summary

• ✅ Factory Pattern helps in creating objects in a clean and controlled way.
• 🧱 Promotes loose coupling, reusability, and maintainability.
• 📦 Useful when object creation is conditional, dynamic, or complex.