Understanding the Factory Method Pattern in Kotlin

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 it 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 Kotlin. 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 it 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 Interface

First, we define an interface for our documents. Kotlin interface Document {// Abstract method to be implemented by concrete document types fun open()} interface Document {// Abstract method to be implemented by concrete document types fun open()} The Document interface declares a 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 interface, WordDocument, and ExcelDocument . Kotlin class WordDocument : Document {override fun open() {println("Opening Word Document.")}} class ExcelDocument : Document {override fun open() {println("Opening Excel Document.")}} class WordDocument : Document {override fun open() {println("Opening Word Document.")}} class ExcelDocument : Document {override fun open() {println("Opening Excel Document.")}} WordDocument and ExcelDocument classes implement the Document interface, 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.

Kotlin

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

    // Factory method to create documents based on the type
    companion object {
        fun getDocument(type: DocumentType): Document {
            return when (type) {
                DocumentType.WORD -> WordDocument()
                DocumentType.EXCEL -> ExcelDocument()
                else -> throw IllegalArgumentException("Unknown document type: $type")
            }
        }
    }
}

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

    // Factory method to create documents based on the type
    companion object {
        fun getDocument(type: DocumentType): Document {
            return when (type) {
                DocumentType.WORD -> WordDocument()
                DocumentType.EXCEL -> ExcelDocument()
                else -> throw 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 Function:
- This is the factory function that takes a DocumentType as a parameter and returns an instance of the corresponding document class.
- The when expression checks the provided document type and creates an instance of WordDocument or ExcelDocument accordingly.
- If an unsupported or unknown document type is passed, the function throws an IllegalArgumentException. This guards against invalid input, ensuring robustness in your code.