Factory Method (patrón de diseño)

En diseño de software, el patrón de diseño Factory Method consiste en utilizar una clase constructora (al estilo del Abstract Factory) abstracta con unos cuantos métodos definidos y otro(s) abstracto(s): el dedicado a la construcción de objetos de un subtipo de un tipo determinado. Es una simplificación del Abstract Factory, en la que la clase abstracta tiene métodos concretos que usan algunos de los abstractos; según usemos una u otra hija de esta clase abstracta, tendremos uno u otro comportamiento.

Este patrón, pretende resolver problemas recurrentes con un diseño flexible y reusable para software orientado a objetos. Específicamente el método Factory resuelve cómo un objeto puede ser creado haciendo que las subclases puedan decidir qué clases instanciar y cómo una clase puede diferir la instanciación de subclases​.

Estructura

Las clases principales en este patrón son el creador y el producto. El creador necesita crear instancias de productos, pero los tipos concretos de cada producto no deben estar reflejadas en el propio creador, sino que las posibles subclases del creador deben poder especificar los tipos concretos, subclases, de los productos para utilizar.

La solución para esto es hacer un método abstracto (el método de la fábrica) que se define en el creador. Este método abstracto se define para que devuelva un producto. Las subclases del creador pueden sobrescribir este método para devolver subclases apropiadas del producto...

Ejemplo de código

Java

abstract class Creator{
    // Definimos método abstracto mal
    public abstract Product factoryMethod();
}

Ahora definimos el creador concreto:

public class ConcreteCreator extends Creator{
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}

Definimos el producto y su implementación concreta:

public interface Product{
    public void operacion();
}

public class ConcreteProduct implements Product{
    public void operacion(){
        System.out.println("Una operación de este producto");
    }
}

Ejemplo de uso:

public static void main(String args[]){
    Creator aCreator;
    aCreator = new ConcreteCreator();
    Product producto = aCreator.factoryMethod();
    producto.operacion();
}

Python

from abc import ABC, abstractmethod


class MazeGame(ABC):
    def __init__(self) -> None:
        self.rooms = []
        self._prepare_rooms()

    def _prepare_rooms(self) -> None:
        room1 = self.make_room()
        room2 = self.make_room()

        room1.connect(room2)
        self.rooms.append(room1)
        self.rooms.append(room2)

    def play(self) -> None:
        print(f"Playing using {self.rooms[0]}")

    @abstractmethod
    def make_room(self):
        raise NotImplementedError("You should implement this!")


class MagicMazeGame(MazeGame):
    def make_room(self) -> "MagicRoom":
        return MagicRoom()


class OrdinaryMazeGame(MazeGame):
    def make_room(self) -> "OrdinaryRoom":
        return OrdinaryRoom()


class Room(ABC):
    def __init__(self) -> None:
        self.connected_rooms = []

    def connect(self, room: "Room") -> None:
        self.connected_rooms.append(room)


class MagicRoom(Room):
    def __str__(self) -> str:
        return "Magic room"


class OrdinaryRoom(Room):
    def __str__(self) -> str:
        return "Ordinary room"


ordinaryGame = OrdinaryMazeGame()
ordinaryGame.play()

magicGame = MagicMazeGame()
magicGame.play()

Enlaces externos

• Patrones de Fabricación: Fábricas de Objetos - Leon Welicki
• Ejemplo en Java con Diagrama UML
• Patrón Factory Method explicado en video, artículo de Lucas Ontivero donde explica, mediante un video de 9 minutos 53 segundos, el patrón Factory Method (nivel muy básico)

• Datos: Q637921
• Multimedia: Factory method / Q637921