Factory Method Pattern

Understanding the Factory Method

Welcome back! We have already covered the Singleton pattern and how it ensures a class has only one instance. Now, let's dive into another essential creational design pattern: the Factory Method pattern . This lesson will guide you through understanding the Factory Method pattern, a powerful tool used to define an interface for creating an object but allows subclasses to alter the type of objects that will be created.

What You'll Learn

In this lesson, you'll gain a solid understanding of the Factory Method pattern in Java. We will focus on: What the Factory Method pattern is and why it is used. How to implement the Factory Method pattern using a factory class. Creating different types of document classes (WordDocument and ExcelDocument) and generating their instances via the factory method.

The Factory Pattern

The Factory Method 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. Instead of calling a constructor directly to create an object, the client calls a factory method defined by an abstract class or interface, which delegates the process to derived classes. This approach promotes loose coupling and adheres to the Open/Closed Principle, allowing a system to be extended without modifying existing code. We'll walk through a code example involving Document, WordDocument, and ExcelDocument classes, managed by a DocumentFactory class.

Step 1: Define the Document Class

First, we define an abstract class for our documents. Java public abstract class Document {// Abstract method to be implemented by concrete document types public abstract void open();} public abstract class Document {// Abstract method to be implemented by concrete document types public abstract void open();} The Document abstract class declares an abstract method open that all document types must implement. This provides a common contract for all documents.

Step 2: Implement Concrete Document Classes

We create two concrete implementations of the Document class, WordDocument and ExcelDocument . Java public class WordDocument extends Document {@Override public void open() {System.out.println("Opening Word Document.");}} public class ExcelDocument extends Document {@Override public void open() {System.out.println("Opening Excel Document.");}} public class WordDocument extends Document {@Override public void open() {System.out.println("Opening Word Document.");}} public class ExcelDocument extends Document {@Override public void open() {System.out.println("Opening Excel Document.");}} WordDocument and ExcelDocument classes extend the Document class, thereby providing specific behavior for opening Word and Excel documents respectively.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Step 3: Create the Factory Class

Next, we create a factory class that provides a method to create instances of Document.

The factory class encapsulates the logic for creating various types of documents without exposing the creation logic to the client. This ensures that the client code doesn't need to know the details of how the documents are created. Instead, it simply calls the factory method and receives the appropriate document instance.

Java

public class DocumentFactory {
    // Enum to define supported document types
    public enum DocumentType {
        WORD, EXCEL
    }

    // Factory method to create documents based on the type
    public static Document getDocument(DocumentType type) {
        switch (type) {
            case WORD:
                return new WordDocument();
            case EXCEL:
                return new ExcelDocument();
            default:
                throw new IllegalArgumentException("Unknown document type: " + type);
        }
    }
}

public class DocumentFactory {
    // Enum to define supported document types
    public enum DocumentType {
        WORD, EXCEL
    }

    // Factory method to create documents based on the type
    public static Document getDocument(DocumentType type) {
        switch (type) {
            case WORD:
                return new WordDocument();
            case EXCEL:
                return new ExcelDocument();
            default:
                throw new IllegalArgumentException("Unknown document type: " + type);
        }
    }
}

The DocumentType Enum:
- This enum defines the supported types of documents (WORD and EXCEL). You can easily extend this enum to include additional document types in the future, making the system flexible and scalable.
The getDocument Method:
- This is the factory method that takes a DocumentType as a parameter and returns an instance of the corresponding document class.
- The switch statement checks the provided document type and creates an instance of WordDocument or ExcelDocument accordingly.
- If an unsupported or unknown document type is passed, the method throws an IllegalArgumentException. This guards against invalid input, ensuring robustness in your code.

Step 4: Object Creation Using The Factory

To complete our understanding, let's see how to use the Factory Method pattern via a main method. This will help you see how the abstract factory and concrete factory classes work together to create and manage different types of documents.