Patterns: Abstract Method

Published: 01/03/25 by stsykalovskyi

Description: The Abstract Method pattern is a creational design pattern that provides an interface for creating objects but allows subclasses to alter the type of objects that will be created.

Category

• Creational

Problem Statement

Context: In software development, we often need to create objects without specifying their concrete classes. The Abstract Method pattern helps by defining an interface for object creation while allowing subclasses to determine the specific implementation.

Example: Consider a document management system that supports different file formats (e.g., PDF, DOCX). Instead of hardcoding object creation for each file type, we can use the Abstract Method pattern to define a common interface and delegate creation to specific subclasses.

Solution

Concept: The Abstract Method pattern defines an abstract interface for creating objects. Subclasses implement this interface to specify which concrete class to instantiate.

Diagram: Include a UML diagram or visual representation.

Implementation: The pattern typically involves an abstract creator class with an abstract method and concrete subclasses that implement the method to return specific instances.

Participants

• Abstract Creator: Defines an abstract method for creating objects.
• Concrete Creator: Implements the abstract method to create specific instances.
• Product Interface: Defines a common interface for created objects.
• Concrete Product: Implements the product interface.

Code Example (in Python)

from abc import ABC, abstractmethod

# Abstract Product
class Document(ABC):
    @abstractmethod
    def render(self):
        pass

# Concrete Products
class PDFDocument(Document):
    def render(self):
        return "Rendering PDF Document"

class WordDocument(Document):
    def render(self):
        return "Rendering Word Document"

# Abstract Creator
class DocumentCreator(ABC):
    @abstractmethod
    def create_document(self):
        pass

# Concrete Creators
class PDFCreator(DocumentCreator):
    def create_document(self):
        return PDFDocument()

class WordCreator(DocumentCreator):
    def create_document(self):
        return WordDocument()

# Client code
def client_code(creator: DocumentCreator):
    document = creator.create_document()
    print(document.render())

client_code(PDFCreator())  # Output: Rendering PDF Document
client_code(WordCreator()) # Output: Rendering Word Document

Advantages

• Provides a flexible and extensible way to create objects.
• Reduces dependency on concrete classes.
• Enhances code maintainability and scalability.

Drawbacks

• Can increase complexity due to additional abstract classes.
• Requires careful implementation to avoid tight coupling between creators and products.

Use Cases

• When the exact type of objects to be created is determined by subclasses.
• When designing frameworks that require a consistent method of object creation.
• When multiple families of related products need to be instantiated dynamically.

Related Patterns

• Factory Method: Similar to Abstract Method but allows subclasses to decide which class to instantiate.
• Prototype: Creates objects by cloning existing instances instead of defining explicit subclasses.

This template helps ensure a consistent and thorough understanding of software design patterns, making them easier to apply in real-world development.

Category: Programming

Tags: patterns