Patrón Decorator

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

El patrón Decorator es un patrón de diseño estructural que te permite añadir nuevos comportamientos a los objetos envolviéndolos en objetos especiales llamados decoradores. A diferencia de la herencia, que añade comportamiento en tiempo de compilación, los decoradores añaden funcionalidad dinámicamente en tiempo de ejecución sin modificar la clase original.

Imagina una cafetería donde empiezas con un café básico y puedes añadir extras como leche, azúcar o nata montada. Cada adición envuelve el café original y añade su coste y descripción. El patrón utiliza una interfaz común para que los objetos decorados puedan tratarse igual que el original:

interface Coffee {
    String getDescription();
    double getCost();
}

class SimpleCoffee implements Coffee {
    public String getDescription() {
        return "Simple Coffee";
    }
    public double getCost() {
        return 2.0;
    }
}

abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;
    
    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
}

class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }
    
    public String getDescription() {
        return coffee.getDescription() + ", Milk";
    }
    
    public double getCost() {
        return coffee.getCost() + 0.5;
    }
}

El decorador mantiene una referencia al objeto envuelto y delega las llamadas en él mientras añade su propio comportamiento. Puedes apilar varios decoradores para combinar funcionalidades:

Coffee order = new SimpleCoffee();
order = new MilkDecorator(order);
order = new SugarDecorator(order);

System.out.println(order.getDescription());  // Simple Coffee, Milk, Sugar
System.out.println(order.getCost());         // 2.75

El patrón Decorator destaca cuando necesitas añadir responsabilidades a los objetos sin crear una explosión de subclases. Cada decorador es independiente, por lo que puedes combinarlos libremente para crear exactamente la combinación de comportamientos que necesitas.

Desafío

Fácil

¡Construyamos un sistema de notificaciones usando el patrón Decorator! Crearás una notificación base que puede mejorarse con diferentes canales de entrega, alertas por correo electrónico, alertas por SMS y notificaciones push, envolviendo decoradores unos alrededor de otros. Esto refleja los sistemas del mundo real, donde un solo mensaje podría necesitar enviarse a través de varios canales simultáneamente.

Organizarás tu código en cuatro archivos:

Notifier.java: Define la interfaz Notifier que sirve como interfaz del componente para tu patrón decorador. Debe declarar un método send(String message) que se encargue de enviar notificaciones.
BasicNotifier.java: Crea la clase de componente concreta que implementa Notifier. Esto representa la forma más sencilla de notificación: una alerta dentro de la aplicación. Cuando se llama a send, debe imprimir In-App: [message].
NotifierDecorators.java: Construye aquí tu jerarquía de decoradores. Comienza con una clase abstracta NotifierDecorator que implemente Notifier y mantenga una referencia a un objeto Notifier envuelto (pasado a través de su constructor).
Después, crea tres decoradores concretos que extiendan NotifierDecorator:

EmailDecorator: cuando se llama a send, primero delega en el notificador envuelto y después imprime Email: [message].

SMSDecorator: cuando se llama a send, primero delega en el notificador envuelto y después imprime SMS: [message].

PushDecorator: cuando se llama a send, primero delega en el notificador envuelto y después imprime Push: [message].
Main.java: ¡Reúne tu sistema de decoradores! Recibirás dos entradas: el mensaje de notificación (String) y una lista separada por comas de los canales que se añadirán (String), por ejemplo "email,sms" o "push,email,sms".
Comienza con un BasicNotifier. Después, según la entrada de canales, envuélvelo con los decoradores apropiados en el orden en que aparecen. Los nombres de canal válidos son email, sms y push.

Finalmente, llama a send con tu mensaje en el notificador completamente decorado.

Recibirás dos entradas en este orden: el mensaje que se enviará (String) y los canales que se habilitarán (String, separados por comas).

Por ejemplo, con las entradas Server is down! y email,push, el resultado sería:

In-App: Server is down!
Email: Server is down!
Push: Server is down!

Observa cómo cada decorador añade su propio comportamiento mientras conserva la notificación original. El orden de envoltura determina el orden de salida: el componente más interno (BasicNotifier) se ejecuta primero y después cada decorador añade su capa. ¡Puedes combinar cualquier combinación de canales sin crear clases independientes para cada combinación!

Pruébalo tú mismo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lee el mensaje a enviar
        String message = scanner.nextLine();
        
        // Lee la lista de canales separados por comas (p. ej., "email,sms" o "push,email,sms")
        String channelsInput = scanner.nextLine();
        
        // TODO: Empieza con un BasicNotifier
        
        // TODO: Divide la entrada de canales por coma
        
        // TODO: Recorre cada canal y envuelve el notificador con el decorador apropiado
        // Los canales válidos son: "email", "sms", "push"
        
        // TODO: Llama a send en el notificador completamente decorado con el mensaje
        
    }
}