Patrón Factory

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy. Lección 66 de 87.

El patrón Factory es un patrón de diseño creacional que delega la creación de objetos a un método o una clase separados. En lugar de usar new directamente en tu código, le pides a una fábrica que cree objetos por ti. Esto resulta especialmente útil cuando tienes varias clases relacionadas que comparten una interfaz o una clase principal común.

Considera un sistema de notificaciones que puede enviar correos electrónicos, SMS o notificaciones push. Sin una fábrica, tu código tendría que conocer cada clase concreta:

// Sin Factory - el cliente debe conocer todas las clases concretas
Notification notification;
if (type.equals("email")) {
    notification = new EmailNotification();
} else if (type.equals("sms")) {
    notification = new SMSNotification();
}

Con el patrón Factory, centralizas esta lógica de creación:

public interface Notification {
    void send(String message);
}

public class EmailNotification implements Notification {
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

public class SMSNotification implements Notification {
    public void send(String message) {
        System.out.println("SMS: " + message);
    }
}

public class NotificationFactory {
    public static Notification create(String type) {
        if (type.equals("email")) {
            return new EmailNotification();
        } else if (type.equals("sms")) {
            return new SMSNotification();
        }
        return null;
    }
}

Ahora el código del cliente es más limpio y no depende de clases concretas:

Notification notification = NotificationFactory.create("email");
notification.send("Hello!");  // Salida: Email: Hello!

El beneficio principal es que añadir nuevos tipos de notificación solo requiere actualizar la fábrica: el código del cliente permanece sin cambios. Esto sigue el principio de programar para una interfaz, lo que hace que tu sistema sea más flexible y fácil de ampliar.

Desafío

Fácil

¡Construyamos un sistema de dibujo de figuras usando el patrón Factory! En lugar de crear objetos de figuras directamente a lo largo de tu código, centralizarás la lógica de creación en una fábrica que produce diferentes tipos de figuras basándose en un identificador de cadena simple.

Organizarás tu código en cuatro archivos:

Shape.java: Define una interfaz llamada Shape que sirva como contrato común para todas las figuras. Tu interfaz debe declarar un único método draw() que no devuelva nada, sino que imprima información sobre la figura que se está dibujando.
Shapes.java: Crea tres clases que implementen tu interfaz Shape:
Circle: su método draw() debe imprimir Drawing a Circle

Rectangle: su método draw() debe imprimir Drawing a Rectangle

Triangle: su método draw() debe imprimir Drawing a Triangle
ShapeFactory.java: Crea la clase fábrica que gestione la creación de figuras. Tu ShapeFactory debe tener un método estático createShape(String type) que devuelva un Shape. Según el parámetro type:
- Si type es igual a "circle", devuelve un Circle nuevo
- Si type es igual a "rectangle", devuelve un Rectangle nuevo
- Si type es igual a "triangle", devuelve un Triangle nuevo
- Para cualquier otro valor, devuelve null
Main.java: ¡Integra tu sistema de fábrica! Recibirás dos entradas: dos tipos de figuras (ambos String).
Para cada entrada, usa tu ShapeFactory para crear la figura y guárdala en una variable Shape. Si la fábrica devuelve una figura válida (no null), llama a su método draw(). Si devuelve null, imprime Unknown shape: [type], donde [type] es la entrada proporcionada.

Procesa ambas entradas en orden, cada una en su propia línea de salida.

Recibirás dos entradas en orden: el primer tipo de figura (String) y el segundo tipo de figura (String).

Observa que tu clase Main nunca usa new Circle() ni new Rectangle() directamente. Solo conoce la interfaz Shape y le pide a la fábrica que cree objetos. ¡Este es el poder del patrón Factory: el código cliente está desacoplado de las clases concretas!

Pruébalo tú mismo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lee dos tipos de formas
        String type1 = scanner.nextLine();
        String type2 = scanner.nextLine();
        
        // TODO: Usa ShapeFactory para crear la primera forma
        // Si la forma no es null, llama a draw()
        // If the shape is null, print "Unknown shape: [type]"
        
        // TODO: Haz lo mismo para la segunda forma
        
    }
}