Understanding the Factory Method Design Pattern

Understanding the Factory Method Design Pattern

Problem

The Factory Method pattern addresses the need to create objects without specifying the exact class of object that will be created. This is useful when you have multiple subclasses of a superclass and want to delegate the object creation to a specific subclass based on certain conditions or parameters.

Solution

The Factory Method pattern provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. This promotes loose coupling by ensuring that the client code interacts with the factory interface rather than the concrete classes directly.

Pros and Cons

Pros

• Decouples Client Code: Allows client code to work with an interface or abstract class for object creation, promoting flexibility and maintainability.
• Promotes Code Reuse: Subclasses can reuse the same object creation logic defined in the factory method.
• Supports Open-Closed Principle: New subclasses can be added without modifying existing client code, adhering to the Open-Closed Principle.

Cons

• Complexity: Introduces additional complexity with the introduction of multiple subclasses and factory methods.
• Requires Subclassing: Each product type requires its own subclass, potentially leading to a proliferation of classes in the codebase.
• Not Suitable for Simple Cases: Overuse of the Factory Method pattern in simple scenarios can lead to unnecessary abstraction and complexity.

Example of Real-World Application

A practical example of the Factory Method pattern is in a framework for creating documents. Depending on the type of document (e.g., PDF, HTML), a corresponding document factory creates the document object with appropriate formatting and features.

Example Code in Java

Factory Method pattern in code

java
// Product interface
public interface Document {
    void open();
    void close();
}

// Concrete Product 1
public class PDFDocument implements Document {
    @Override
    public void open() {
        System.out.println("Opening PDF document");
    }

    @Override
    public void close() {
        System.out.println("Closing PDF document");
    }
}

// Concrete Product 2
public class HTMLDocument implements Document {
    @Override
    public void open() {
        System.out.println("Opening HTML document");
    }

    @Override
    public void close() {
        System.out.println("Closing HTML document");
    }
}

// Creator interface
public interface DocumentFactory {
    Document createDocument();
}

// Concrete Creator 1
public class PDFDocumentFactory implements DocumentFactory {
    @Override
    public Document createDocument() {
        return new PDFDocument();
    }
}

// Concrete Creator 2
public class HTMLDocumentFactory implements DocumentFactory {
    @Override
    public Document createDocument() {
        return new HTMLDocument();
    }
}

// Client code
public class Client {
    public static void main(String[] args) {
        DocumentFactory factory1 = new PDFDocumentFactory();
        Document pdfDocument = factory1.createDocument();
        pdfDocument.open();
        pdfDocument.close();

        DocumentFactory factory2 = new HTMLDocumentFactory();
        Document htmlDocument = factory2.createDocument();
        htmlDocument.open();
        htmlDocument.close();
    }
}

The above is the detailed content of Understanding the Factory Method Design Pattern. For more information, please follow other related articles on the PHP Chinese website!