Patrones de Diseño en Java

public class SingletonBasico {

    // Instancia única, inicialmente null
    private static SingletonBasico instancia;

    // Constructor privado: nadie externo puede crear instancias
    private SingletonBasico() {
        System.out.println("Singleton creado");
    }

    // Punto de acceso global (NO thread-safe)
    public static SingletonBasico getInstancia() {
        if (instancia == null) {
            instancia = new SingletonBasico();
        }
        return instancia;
    }

    public void operacion() {
        System.out.println("Operación del Singleton ejecutada");
    }
}

public class SingletonBillPugh {

    // Constructor privado
    private SingletonBillPugh() {
        System.out.println("Singleton creado de forma segura");
    }

    // Clase interna estática: se carga SOLO cuando se referencia
    private static class Holder {
        private static final SingletonBillPugh INSTANCIA = new SingletonBillPugh();
    }

    // Thread-safe por garantía de la JVM (carga de clases es atómica)
    public static SingletonBillPugh getInstancia() {
        return Holder.INSTANCIA;
    }

    public void configurar(String parametro) {
        System.out.println("Configurando con: " + parametro);
    }
}

// Uso:
// SingletonBillPugh config = SingletonBillPugh.getInstancia();
// config.configurar("produccion");

// Producto: interfaz común
public interface Documento {
    void abrir();
    void guardar();
    String getTipo();
}

// Productos concretos
public class DocumentoPDF implements Documento {
    @Override
    public void abrir() {
        System.out.println("Abriendo documento PDF con visor integrado");
    }

    @Override
    public void guardar() {
        System.out.println("Guardando PDF con compresión estándar");
    }

    @Override
    public String getTipo() { return "PDF"; }
}

public class DocumentoWord implements Documento {
    @Override
    public void abrir() {
        System.out.println("Abriendo documento Word en modo edición");
    }

    @Override
    public void guardar() {
        System.out.println("Guardando Word con formato OOXML");
    }

    @Override
    public String getTipo() { return "Word"; }
}

public class DocumentoCSV implements Documento {
    @Override
    public void abrir() {
        System.out.println("Abriendo CSV en vista tabular");
    }

    @Override
    public void guardar() {
        System.out.println("Guardando CSV con delimitador punto y coma");
    }

    @Override
    public String getTipo() { return "CSV"; }
}

// Creador abstracto: define el Factory Method
public abstract class EditorDocumentos {

    // Factory Method: las subclases deciden qué Documento crear
    protected abstract Documento crearDocumento();

    // Método que usa el Factory Method (Template Method implícito)
    public void nuevoDocumento() {
        Documento doc = crearDocumento();  // Delegación a subclases
        System.out.println("Creado documento de tipo: " + doc.getTipo());
        doc.abrir();
    }
}

// Creadores concretos
public class EditorPDF extends EditorDocumentos {
    @Override
    protected Documento crearDocumento() {
        return new DocumentoPDF();
    }
}

public class EditorWord extends EditorDocumentos {
    @Override
    protected Documento crearDocumento() {
        return new DocumentoWord();
    }
}

// Uso:
// EditorDocumentos editor = new EditorPDF();
// editor.nuevoDocumento();
// Salida:
//   Creado documento de tipo: PDF
//   Abriendo documento PDF con visor integrado

import java.util.ArrayList;
import java.util.List;

// Interfaz del observador
public interface ObservadorPrecio {
    void actualizar(String producto, double precioAnterior, double precioNuevo);
}

// Sujeto observable
public class ProductoMonitorizado {
    private String nombre;
    private double precio;
    private List<ObservadorPrecio> observadores = new ArrayList<>();

    public ProductoMonitorizado(String nombre, double precioInicial) {
        this.nombre = nombre;
        this.precio = precioInicial;
    }

    public void agregarObservador(ObservadorPrecio obs) {
        observadores.add(obs);
    }

    public void eliminarObservador(ObservadorPrecio obs) {
        observadores.remove(obs);
    }

    // Al cambiar el precio, se notifica a todos los observadores
    public void setPrecio(double nuevoPrecio) {
        double anterior = this.precio;
        this.precio = nuevoPrecio;
        if (anterior != nuevoPrecio) {
            notificarObservadores(anterior, nuevoPrecio);
        }
    }

    private void notificarObservadores(double anterior, double nuevo) {
        for (ObservadorPrecio obs : observadores) {
            obs.actualizar(nombre, anterior, nuevo);
        }
    }

    public double getPrecio() { return precio; }
    public String getNombre() { return nombre; }
}

// Observadores concretos
public class AlertaEmail implements ObservadorPrecio {
    private String destinatario;

    public AlertaEmail(String destinatario) {
        this.destinatario = destinatario;
    }

    @Override
    public void actualizar(String producto, double anterior, double nuevo) {
        if (nuevo < anterior) {
            System.out.printf("[EMAIL → %s] ¡%s ha bajado de %.2f€ a %.2f€!%n",
                destinatario, producto, anterior, nuevo);
        }
    }
}

public class RegistroHistorial implements ObservadorPrecio {
    @Override
    public void actualizar(String producto, double anterior, double nuevo) {
        double variacion = ((nuevo - anterior) / anterior) * 100;
        System.out.printf("[HISTORIAL] %s: %.2f€ → %.2f€ (%.1f%%)%n",
            producto, anterior, nuevo, variacion);
    }
}

// Uso:
// ProductoMonitorizado laptop = new ProductoMonitorizado("MacBook Pro", 2499.00);
// laptop.agregarObservador(new AlertaEmail("ana@empresa.com"));
// laptop.agregarObservador(new RegistroHistorial());
// laptop.setPrecio(2299.00);
// Salida:
//   [EMAIL → ana@empresa.com] ¡MacBook Pro ha bajado de 2499.00€ a 2299.00€!
//   [HISTORIAL] MacBook Pro: 2499.00€ → 2299.00€ (-8.0%)

// Interfaz Strategy
@FunctionalInterface
public interface EstrategiaDescuento {
    double calcularDescuento(double precioOriginal);
}

// Estrategias concretas
public class DescuentoPorcentaje implements EstrategiaDescuento {
    private double porcentaje;

    public DescuentoPorcentaje(double porcentaje) {
        this.porcentaje = porcentaje;
    }

    @Override
    public double calcularDescuento(double precioOriginal) {
        return precioOriginal * (porcentaje / 100.0);
    }
}

public class DescuentoCantidadFija implements EstrategiaDescuento {
    private double cantidad;

    public DescuentoCantidadFija(double cantidad) {
        this.cantidad = cantidad;
    }

    @Override
    public double calcularDescuento(double precioOriginal) {
        return Math.min(cantidad, precioOriginal); // No superar el precio
    }
}

public class DescuentoBlackFriday implements EstrategiaDescuento {
    @Override
    public double calcularDescuento(double precioOriginal) {
        // 30% de descuento + 10€ adicionales si supera 100€
        double descuento = precioOriginal * 0.30;
        if (precioOriginal > 100.0) {
            descuento += 10.0;
        }
        return Math.min(descuento, precioOriginal);
    }
}

// Contexto que usa la estrategia
public class CarritoCompra {
    private double total;
    private EstrategiaDescuento estrategia;

    public CarritoCompra(double total) {
        this.total = total;
    }

    // Cambiar estrategia en tiempo de ejecución
    public void setEstrategiaDescuento(EstrategiaDescuento estrategia) {
        this.estrategia = estrategia;
    }

    public double calcularPrecioFinal() {
        if (estrategia == null) {
            return total;
        }
        double descuento = estrategia.calcularDescuento(total);
        return total - descuento;
    }

    public void mostrarResumen() {
        double descuento = (estrategia != null)
            ? estrategia.calcularDescuento(total) : 0;
        System.out.printf("Total: %.2f€ | Descuento: %.2f€ | Final: %.2f€%n",
            total, descuento, total - descuento);
    }
}

// Uso:
// CarritoCompra carrito = new CarritoCompra(250.00);
//
// carrito.setEstrategiaDescuento(new DescuentoPorcentaje(15));
// carrito.mostrarResumen();
// → Total: 250.00€ | Descuento: 37.50€ | Final: 212.50€
//
// carrito.setEstrategiaDescuento(new DescuentoBlackFriday());
// carrito.mostrarResumen();
// → Total: 250.00€ | Descuento: 85.00€ | Final: 165.00€
//
// // Con lambda (Java 8+):
// carrito.setEstrategiaDescuento(precio -> precio * 0.05);
// carrito.mostrarResumen();
// → Total: 250.00€ | Descuento: 12.50€ | Final: 237.50€

import java.util.ArrayList;
import java.util.List;

// === STRATEGY: Política de prioridad ===
@FunctionalInterface
interface PoliticaPrioridad {
    boolean debeNotificar(String tipoEvento, String nivelCliente);
}

class PrioridadTodo implements PoliticaPrioridad {
    @Override
    public boolean debeNotificar(String tipoEvento, String nivelCliente) {
        return true; // Notificar siempre
    }
}

class PrioridadSoloVIP implements PoliticaPrioridad {
    @Override
    public boolean debeNotificar(String tipoEvento, String nivelCliente) {
        return "VIP".equals(nivelCliente);
    }
}

// === FACTORY METHOD: Canales de notificación ===
interface CanalNotificacion {
    void enviar(String destinatario, String mensaje);
    String getNombreCanal();
}

class CanalEmail implements CanalNotificacion {
    @Override
    public void enviar(String destinatario, String mensaje) {
        System.out.printf("  📧 EMAIL → %s: %s%n", destinatario, mensaje);
    }
    @Override
    public String getNombreCanal() { return "Email"; }
}

class CanalSMS implements CanalNotificacion {
    @Override
    public void enviar(String destinatario, String mensaje) {
        System.out.printf("  📱 SMS → %s: %s%n", destinatario, mensaje);
    }
    @Override
    public String getNombreCanal() { return "SMS"; }
}

class CanalPush implements CanalNotificacion {
    @Override
    public void enviar(String destinatario, String mensaje) {
        System.out.printf("  🔔 PUSH → %s: %s%n", destinatario, mensaje);
    }
    @Override
    public String getNombreCanal() { return "Push"; }
}

// Factory Method
abstract class FabricaCanal {
    abstract CanalNotificacion crearCanal();
}

class FabricaEmail extends FabricaCanal {
    @Override
    CanalNotificacion crearCanal() { return new CanalEmail(); }
}

class FabricaSMS extends FabricaCanal {
    @Override
    CanalNotificacion crearCanal() { return new CanalSMS(); }
}

// === OBSERVER: Suscriptores de eventos ===
interface SuscriptorPedido {
    void notificar(String tipoEvento, String detalle);
    String getIdentificador();
    String getNivelCliente();
}

class ClienteSuscriptor implements SuscriptorPedido {
    private String nombre;
    private String contacto;
    private String nivel;
    private CanalNotificacion canal;

    public ClienteSuscriptor(String nombre, String contacto,
                              String nivel, CanalNotificacion canal) {
        this.nombre = nombre;
        this.contacto = contacto;
        this.nivel = nivel;
        this.canal = canal;
    }

    @Override
    public void notificar(String tipoEvento, String detalle) {
        canal.enviar(contacto, "[" + tipoEvento + "] " + detalle);
    }

    @Override
    public String getIdentificador() { return nombre; }

    @Override
    public String getNivelCliente() { return nivel; }
}

// Servicio central (Sujeto Observable + usa Strategy)
class ServicioPedidos {
    private List<SuscriptorPedido> suscriptores = new ArrayList<>();
    private PoliticaPrioridad politica = new PrioridadTodo(); // Strategy

    public void setPoliticaPrioridad(PoliticaPrioridad politica) {
        this.politica = politica;
    }

    public void suscribir(SuscriptorPedido s) {
        suscriptores.add(s);
        System.out.println("✓ Suscrito: " + s.getIdentificador());
    }

    public void procesarPedido(String pedidoId, String detalle) {
        System.out.println("\n🛒 Procesando pedido " + pedidoId + "...");
        emitirEvento("PEDIDO_CONFIRMADO",
            "Pedido " + pedidoId + " - " + detalle);
    }

    private void emitirEvento(String tipo, String detalle) {
        System.out.println("  Notificando (política: "
            + politica.getClass().getSimpleName() + "):");
        for (SuscriptorPedido s : suscriptores) {
            if (politica.debeNotificar(tipo, s.getNivelCliente())) {
                s.notificar(tipo, detalle);
            } else {
                System.out.printf("  ⏭️ Omitido: %s (nivel: %s)%n",
                    s.getIdentificador(), s.getNivelCliente());
            }
        }
    }
}

// === PROGRAMA PRINCIPAL ===
// ServicioPedidos servicio = new ServicioPedidos();
//
// // Factory Method crea los canales
// CanalNotificacion email = new FabricaEmail().crearCanal();
// CanalNotificacion sms   = new FabricaSMS().crearCanal();
//
// // Observer: suscribir clientes
// servicio.suscribir(new ClienteSuscriptor("Ana", "ana@mail.com", "VIP", email));
// servicio.suscribir(new ClienteSuscriptor("Luis", "+34600123456", "Standard", sms));
//
// // Strategy: notificar a todos
// servicio.setPoliticaPrioridad(new PrioridadTodo());
// servicio.procesarPedido("P-1001", "MacBook Pro 16\"");
//
// // Cambiar Strategy: solo VIP
// servicio.setPoliticaPrioridad(new PrioridadSoloVIP());
// servicio.procesarPedido("P-1002", "iPhone 16 Pro");

// Salida:
// ✓ Suscrito: Ana
// ✓ Suscrito: Luis
//
// 🛒 Procesando pedido P-1001...
//   Notificando (política: PrioridadTodo):
//   📧 EMAIL → ana@mail.com: [PEDIDO_CONFIRMADO] Pedido P-1001 - MacBook Pro 16"
//   📱 SMS → +34600123456: [PEDIDO_CONFIRMADO] Pedido P-1001 - MacBook Pro 16"
//
// 🛒 Procesando pedido P-1002...
//   Notificando (política: PrioridadSoloVIP):
//   📧 EMAIL → ana@mail.com: [PEDIDO_CONFIRMADO] Pedido P-1002 - iPhone 16 Pro
//   ⏭️ Omitido: Luis (nivel: Standard)

// ❌ SOBREINGENIERÍA: Factory + Strategy + Builder para una suma
SumaFactory factory = new SumaFactoryImpl();
EstrategiaSuma estrategia = factory.crearEstrategia("basica");
ResultadoSuma resultado = new ResultadoSumaBuilder()
    .conOperandoA(3)
    .conOperandoB(5)
    .conEstrategia(estrategia)
    .build();

// ✅ SOLUCIÓN DIRECTA: para una suma, basta con sumar
int resultado = 3 + 5;