Java Notes

Factory Design Pattern

Complete guide to Factory patterns — Simple Factory, Factory Method, and Abstract Factory with UML, Java implementations, and real-world applications.

Intent

Define an interface for creating objects, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

UML Structure — Factory Method

┌───────────────────┐ ┌───────────────────┐ │ Creator │ │ Product │ │ (abstract) │ │ (interface) │ ├───────────────────┤ ├───────────────────┤ │ │────────▶│ + operation() │ │ + factoryMethod() │ └───────┬───────────┘ │ + someOperation() │ │ └───────┬───────────┘ │ implements │ extends │ ┌───────┴───────────┐ ┌──────┴────────────┐ │ ConcreteCreator │ │ ConcreteProduct │ ├───────────────────┤ ├───────────────────┤ │ + factoryMethod() │─creates─▶│ + operation() │ └───────────────────┘ └───────────────────┘

When to Use

You don't know in advance which class to instantiate
A class wants its subclasses to specify the objects it creates
You want to centralize object creation logic
You need to decouple client code from concrete classes
Adding new product types should not require modifying existing code (Open/Closed)

Factory Method Pattern

java example

// Product hierarchy
interface Document {
    void open();
    void save();
    String getType();
}

class PDFDocument implements Document {
    @Override public void open() { System.out.println("Opening PDF viewer"); }
    @Override public void save() { System.out.println("Saving as .pdf"); }
    @Override public String getType() { return "PDF"; }
}

class WordDocument implements Document {
    @Override public void open() { System.out.println("Opening Word processor"); }
    @Override public void save() { System.out.println("Saving as .docx"); }
    @Override public String getType() { return "Word"; }
}

class SpreadsheetDocument implements Document {
    @Override public void open() { System.out.println("Opening spreadsheet app"); }
    @Override public void save() { System.out.println("Saving as .xlsx"); }
    @Override public String getType() { return "Spreadsheet"; }
}

// Creator hierarchy
abstract class Application {
    // Factory Method — subclasses decide what to create
    protected abstract Document createDocument();
    
    // Template method using the factory
    public void newDocument() {
        Document doc = createDocument();
        System.out.println("Created " + doc.getType() + " document");
        doc.open();
    }
    
    public void saveDocument() {
        Document doc = createDocument();
        doc.save();
    }
}

class PDFApplication extends Application {
    @Override
    protected Document createDocument() {
        return new PDFDocument();
    }
}

class WordApplication extends Application {
    @Override
    protected Document createDocument() {
        return new WordDocument();
    }
}

// Usage
public class FactoryMethodDemo {
    public static void main(String[] args) {
        Application app = new PDFApplication();
        app.newDocument(); // Creates PDF without client knowing
        
        app = new WordApplication();
        app.newDocument(); // Creates Word document
    }
}

Output

Created " + doc.getType() + " document

Abstract Factory Pattern

Creates families of related objects without specifying concrete classes.

WindowsGUI		MacGUIFactory
Factory

Example

// Abstract products interface Button { void render(); void onClick(Runnable action); } interface TextField { void render(); String getValue(); } interface Checkbox { void render(); boolean isChecked(); } // Concrete products — Windows family class WindowsButton implements Button { @Override public void render() { System.out.println("[Windows Button]"); } @Override public void onClick(Runnable action) { action.run(); } } class WindowsTextField implements TextField { @Override public void render() { System.out.println("[Windows TextField]"); } @Override public String getValue() { return "Windows input"; } } class WindowsCheckbox implements Checkbox { @Override public void render() { System.out.println("[✓] Windows Checkbox"); } @Override public boolean isChecked() { return true; } } // Concrete products — Mac family class MacButton implements Button { @Override public void render() { System.out.println("( Mac Button )"); } @Override public void onClick(Runnable action) { action.run(); } } class MacTextField implements TextField { @Override public void render() { System.out.println("[ Mac TextField ]"); } @Override public String getValue() { return "Mac input"; } } class MacCheckbox implements Checkbox { @Override public void render() { System.out.println("(●) Mac Checkbox"); } @Override public boolean isChecked() { return true; } } // Abstract Factory interface GUIFactory { Button createButton(); TextField createTextField(); Checkbox createCheckbox(); } // Concrete factories class WindowsGUIFactory implements GUIFactory { @Override public Button createButton() { return new WindowsButton(); } @Override public TextField createTextField() { return new WindowsTextField(); } @Override public Checkbox createCheckbox() { return new WindowsCheckbox(); } } class MacGUIFactory implements GUIFactory { @Override public Button createButton() { return new MacButton(); } @Override public TextField createTextField() { return new MacTextField(); } @Override public Checkbox createCheckbox() { return new MacCheckbox(); } } // Client — works with ANY factory (platform-independent) class LoginForm { private final Button submitButton; private final TextField usernameField; private final TextField passwordField; private final Checkbox rememberMe; public LoginForm(GUIFactory factory) { this.submitButton = factory.createButton(); this.usernameField = factory.createTextField(); this.passwordField = factory.createTextField(); this.rememberMe = factory.createCheckbox(); } public void render() { System.out.println("--- Login Form ---"); usernameField.render(); passwordField.render(); rememberMe.render(); submitButton.render(); } } // Application selects factory based on OS public class AbstractFactoryDemo { public static void main(String[] args) { String os = System.getProperty("os.name").toLowerCase(); GUIFactory factory = os.contains("win") ? new WindowsGUIFactory() : new MacGUIFactory(); LoginForm form = new LoginForm(factory); form.render(); } }

Output

--- Login Form ---

Factory with Java 8 (Functional Approach)

java example

import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;

public class FunctionalFactory {
    private static final Map<String, Supplier<Notification>> registry = new HashMap<>();
    
    static {
        registry.put("email", EmailNotification::new);
        registry.put("sms", SMSNotification::new);
        registry.put("push", PushNotification::new);
    }
    
    public static Notification create(String type) {
        Supplier<Notification> supplier = registry.get(type.toLowerCase());
        if (supplier == null) {
            throw new IllegalArgumentException("Unknown notification type: " + type);
        }
        return supplier.get();
    }
    
    // Open for extension — register new types without modifying factory
    public static void register(String type, Supplier<Notification> creator) {
        registry.put(type.toLowerCase(), creator);
    }
}

// Usage
FunctionalFactory.register("slack", SlackNotification::new);
Notification n = FunctionalFactory.create("slack");

Interview Questions

Q1: What is the difference between Simple Factory, Factory Method, and Abstract Factory?

Answer: Simple Factory uses a static method with conditional logic (not a true pattern). Factory Method defines a creation interface, letting subclasses decide. Abstract Factory creates families of related products — it\'s a factory of factories.

Q2: How does Factory pattern support Open/Closed principle?

Answer: New product types can be added by creating new concrete classes and factories without modifying existing code. The client depends on abstractions, not concrete classes.

Q3: Where is Factory pattern used in Java standard library?

Answer: Calendar.getInstance(), NumberFormat.getInstance(), Collection.iterator(), DriverManager.getConnection(), DocumentBuilderFactory.newInstance().

Q4: When would you choose Factory Method over Abstract Factory?

Answer: Factory Method when you have one product hierarchy and want subclasses to choose the concrete type. Abstract Factory when you have multiple related product families that must be used together consistently.

Q5: How would you make a factory extensible at runtime?

Answer: Use a registry pattern (Map of type→creator). New types are registered with register(type, factory). Can use Supplier<T> or constructor references in Java 8+.

Summary

In this chapter, we learned about Factory Design Pattern in detail. Here are the key points:

Basic introduction to the concept and why it is needed
Syntax and structure with complete examples
Internal working and best practices
Real-world applications and use cases
Common mistakes and how to avoid them
How this topic is asked in interviews

To practice these concepts, write and run the code in your IDE and verify the output. Modify each example and experiment so that you deeply understand the concept.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Factory Design Pattern.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, design, patterns, factory

Continue learning this concept

Design PatternsAdapter Design PatternComplete guide to Adapter pattern — class adapter vs object adapter, real-world integration scenarios, and bridging incompatible interfaces in Java.Design PatternsBuilder Design PatternComplete guide to Builder pattern — step-by-step construction, fluent interfaces, Director, telescoping constructor problem, and real-world Java implementations.Design PatternsMVC Pattern — Java ProgrammingComplete guide to Model-View-Controller pattern — separation of concerns, Java implementation, comparison with other architectural patterns, and real-world applications.Design PatternsObserver Design PatternComplete guide to Observer pattern — publish-subscribe mechanism, event handling, loose coupling, Java implementation with real-world examples.Design PatternsSingleton Design PatternComplete guide to Singleton pattern — all implementation approaches, thread safety, serialization protection, enum singleton, and when to use vs avoid.Collections FrameworkCollections Framework OverviewComplete guide to Java Collections Framework covering hierarchy, interfaces, implementations, algorithms, and choosing the right collection for your use case.

PreviousBuilder Design Pattern NextMVC Pattern — Java Programming

Java Notes

Factory Design Pattern

Complete guide to Factory patterns — Simple Factory, Factory Method, and Abstract Factory with UML, Java implementations, and real-world applications.

Intent

Define an interface for creating objects, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

UML Structure — Factory Method

When to Use

You don't know in advance which class to instantiate
A class wants its subclasses to specify the objects it creates
You want to centralize object creation logic
You need to decouple client code from concrete classes
Adding new product types should not require modifying existing code (Open/Closed)

Factory Method Pattern

java example

// Product hierarchy
interface Document {
    void open();
    void save();
    String getType();
}

class PDFDocument implements Document {
    @Override public void open() { System.out.println("Opening PDF viewer"); }
    @Override public void save() { System.out.println("Saving as .pdf"); }
    @Override public String getType() { return "PDF"; }
}

class WordDocument implements Document {
    @Override public void open() { System.out.println("Opening Word processor"); }
    @Override public void save() { System.out.println("Saving as .docx"); }
    @Override public String getType() { return "Word"; }
}

class SpreadsheetDocument implements Document {
    @Override public void open() { System.out.println("Opening spreadsheet app"); }
    @Override public void save() { System.out.println("Saving as .xlsx"); }
    @Override public String getType() { return "Spreadsheet"; }
}

// Creator hierarchy
abstract class Application {
    // Factory Method — subclasses decide what to create
    protected abstract Document createDocument();
    
    // Template method using the factory
    public void newDocument() {
        Document doc = createDocument();
        System.out.println("Created " + doc.getType() + " document");
        doc.open();
    }
    
    public void saveDocument() {
        Document doc = createDocument();
        doc.save();
    }
}

class PDFApplication extends Application {
    @Override
    protected Document createDocument() {
        return new PDFDocument();
    }
}

class WordApplication extends Application {
    @Override
    protected Document createDocument() {
        return new WordDocument();
    }
}

// Usage
public class FactoryMethodDemo {
    public static void main(String[] args) {
        Application app = new PDFApplication();
        app.newDocument(); // Creates PDF without client knowing
        
        app = new WordApplication();
        app.newDocument(); // Creates Word document
    }
}

Output

Created " + doc.getType() + " document

Abstract Factory Pattern

Creates families of related objects without specifying concrete classes.

WindowsGUI		MacGUIFactory
Factory

Example

Output

--- Login Form ---

Factory with Java 8 (Functional Approach)

java example

import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;

public class FunctionalFactory {
    private static final Map<String, Supplier<Notification>> registry = new HashMap<>();
    
    static {
        registry.put("email", EmailNotification::new);
        registry.put("sms", SMSNotification::new);
        registry.put("push", PushNotification::new);
    }
    
    public static Notification create(String type) {
        Supplier<Notification> supplier = registry.get(type.toLowerCase());
        if (supplier == null) {
            throw new IllegalArgumentException("Unknown notification type: " + type);
        }
        return supplier.get();
    }
    
    // Open for extension — register new types without modifying factory
    public static void register(String type, Supplier<Notification> creator) {
        registry.put(type.toLowerCase(), creator);
    }
}

// Usage
FunctionalFactory.register("slack", SlackNotification::new);
Notification n = FunctionalFactory.create("slack");

Interview Questions

Q1: What is the difference between Simple Factory, Factory Method, and Abstract Factory?

Q2: How does Factory pattern support Open/Closed principle?

Answer: New product types can be added by creating new concrete classes and factories without modifying existing code. The client depends on abstractions, not concrete classes.

Q3: Where is Factory pattern used in Java standard library?

Answer: Calendar.getInstance(), NumberFormat.getInstance(), Collection.iterator(), DriverManager.getConnection(), DocumentBuilderFactory.newInstance().

Q4: When would you choose Factory Method over Abstract Factory?

Q5: How would you make a factory extensible at runtime?

Answer: Use a registry pattern (Map of type→creator). New types are registered with register(type, factory). Can use Supplier<T> or constructor references in Java 8+.

Summary

In this chapter, we learned about Factory Design Pattern in detail. Here are the key points:

Basic introduction to the concept and why it is needed
Syntax and structure with complete examples
Internal working and best practices
Real-world applications and use cases
Common mistakes and how to avoid them
How this topic is asked in interviews

To practice these concepts, write and run the code in your IDE and verify the output. Modify each example and experiment so that you deeply understand the concept.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Factory Design Pattern.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, design, patterns, factory

Continue learning this concept

PreviousBuilder Design Pattern NextMVC Pattern — Java Programming