El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Factory Method

Siguiente ►
►

Introducción

El patrón Factory Method es uno de los patrones creacionales más utilizados en el diseño de software. Este patrón proporciona una interfaz para crear objetos en una superclase, pero permite a las subclases alterar el tipo de objetos que se crearán. Es especialmente útil cuando el proceso de creación de un objeto es complejo o cuando el tipo de objeto a crear puede variar.

Objetivos del Módulo

  • Comprender el propósito y la estructura del patrón Factory Method.
  • Aprender a implementar el patrón Factory Method en un lenguaje de programación.
  • Conocer las ventajas y desventajas del uso del patrón Factory Method.
  • Practicar con ejemplos y ejercicios para reforzar el aprendizaje.

¿Qué es el Factory Method?

El Factory Method define una interfaz para crear un objeto, pero permite que las subclases decidan qué clase instanciar. De esta manera, el método de creación de objetos se delega a las subclases.

Estructura del Factory Method

La estructura básica del patrón Factory Method incluye los siguientes componentes:

  1. Producto (Product): Define la interfaz de los objetos que el método de fábrica crea.
  2. Producto Concreto (ConcreteProduct): Implementa la interfaz del Producto.
  3. Creador (Creator): Declara el método de fábrica, que devuelve un objeto de tipo Producto. Puede incluir una implementación predeterminada del método de fábrica.
  4. Creador Concreto (ConcreteCreator): Sobrescribe el método de fábrica para devolver una instancia de un Producto Concreto.

Diagrama UML

+----------------+          +-----------------+
|   Creator      |          |   Product       |
|----------------|          |-----------------|
| + factoryMethod|<-------->| + operation()   |
|----------------|          +-----------------+
| + anOperation()|
+----------------+
       ^
       |
+----------------+
|ConcreteCreator |
|----------------|
| + factoryMethod|
+----------------+

Implementación del Factory Method

A continuación, se presenta un ejemplo de implementación del patrón Factory Method en Python.

Ejemplo en Python

Supongamos que estamos desarrollando una aplicación que necesita crear diferentes tipos de documentos (PDF, Word). Utilizaremos el patrón Factory Method para crear estos documentos.

from abc import ABC, abstractmethod

# Producto
class Document(ABC):
    @abstractmethod
    def create(self):
        pass

# Producto Concreto
class PDFDocument(Document):
    def create(self):
        return "PDF Document Created"

class WordDocument(Document):
    def create(self):
        return "Word Document Created"

# Creador
class DocumentCreator(ABC):
    @abstractmethod
    def factory_method(self):
        pass

    def create_document(self):
        document = self.factory_method()
        return document.create()

# Creador Concreto
class PDFDocumentCreator(DocumentCreator):
    def factory_method(self):
        return PDFDocument()

class WordDocumentCreator(DocumentCreator):
    def factory_method(self):
        return WordDocument()

# Uso del patrón Factory Method
def main():
    creators = [PDFDocumentCreator(), WordDocumentCreator()]
    for creator in creators:
        print(creator.create_document())

if __name__ == "__main__":
    main()

Explicación del Código

  1. Document (Producto): Define la interfaz create que debe implementar cualquier tipo de documento.
  2. PDFDocument y WordDocument (Producto Concreto): Implementan la interfaz Document y proporcionan su propia versión del método create.
  3. DocumentCreator (Creador): Declara el método de fábrica factory_method y el método create_document que utiliza el método de fábrica para crear un documento.
  4. PDFDocumentCreator y WordDocumentCreator (Creador Concreto): Sobrescriben el método de fábrica para devolver una instancia de PDFDocument y WordDocument, respectivamente.
  5. main: Demuestra cómo utilizar los creadores concretos para crear diferentes tipos de documentos.

Ventajas y Desventajas del Factory Method

Ventajas

  • Flexibilidad: Permite a las subclases decidir qué clase instanciar.
  • Desacoplamiento: Desacopla el código de creación de objetos del código que utiliza los objetos.
  • Extensibilidad: Facilita la adición de nuevos tipos de productos sin modificar el código existente.

Desventajas

  • Complejidad: Puede aumentar la complejidad del código debido a la introducción de múltiples subclases.
  • Sobrecarga: Puede ser excesivo para aplicaciones simples donde no se requiere tanta flexibilidad.

Ejercicio Práctico

Ejercicio 1

Implemente el patrón Factory Method para una aplicación que crea diferentes tipos de vehículos (Coche, Moto).

Solución

from abc import ABC, abstractmethod

# Producto
class Vehicle(ABC):
    @abstractmethod
    def create(self):
        pass

# Producto Concreto
class Car(Vehicle):
    def create(self):
        return "Car Created"

class Motorcycle(Vehicle):
    def create(self):
        return "Motorcycle Created"

# Creador
class VehicleCreator(ABC):
    @abstractmethod
    def factory_method(self):
        pass

    def create_vehicle(self):
        vehicle = self.factory_method()
        return vehicle.create()

# Creador Concreto
class CarCreator(VehicleCreator):
    def factory_method(self):
        return Car()

class MotorcycleCreator(VehicleCreator):
    def factory_method(self):
        return Motorcycle()

# Uso del patrón Factory Method
def main():
    creators = [CarCreator(), MotorcycleCreator()]
    for creator in creators:
        print(creator.create_vehicle())

if __name__ == "__main__":
    main()

Retroalimentación

  • Error Común: Olvidar implementar el método factory_method en las subclases concretas.
  • Consejo: Asegúrese de que cada subclase concreta sobrescriba el método factory_method para devolver la instancia correcta del producto.

Conclusión

El patrón Factory Method es una herramienta poderosa para manejar la creación de objetos en el diseño de software. Proporciona flexibilidad y desacoplamiento, permitiendo que las subclases decidan qué clase instanciar. Sin embargo, es importante usarlo con cuidado para evitar una complejidad innecesaria en el código.

En el siguiente módulo, exploraremos otro patrón creacional: el patrón Abstract Factory. Este patrón lleva el concepto de Factory Method un paso más allá, permitiendo la creación de familias de objetos relacionados.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados