Patrón Bridge en Java: desacoplar abstracción de implementación

// 3 tipos × 3 canales = 9 clases (¡y creciendo!)
NotificacionUrgenteEmail
NotificacionUrgenteSMS
NotificacionUrgentePush
NotificacionInformativaEmail
NotificacionInformativaSMS
NotificacionInformativaPush
NotificacionRecordatorioEmail
NotificacionRecordatorioSMS
NotificacionRecordatorioPush

// Si añadimos un 4º canal (Slack), necesitamos 3 clases más.
// Si añadimos un 4º tipo, necesitamos 4 clases más.
// Complejidad: M × N clases.

// Abstracción: 3 clases (tipos)
Notificacion (abstracta) → contiene referencia a CanalEnvio
  ├── NotificacionUrgente
  ├── NotificacionInformativa
  └── NotificacionRecordatorio

// Implementación: 3 clases (canales)
CanalEnvio (interfaz)
  ├── CanalEmail
  ├── CanalSMS
  └── CanalPush

// Total: 3 + 3 = 6 clases (en vez de 9)
// Con 5 tipos + 5 canales: 5 + 5 = 10 clases (en vez de 25)

┌──────────────────────┐         ┌────────────────────────┐
│    «abstract»        │         │    «interface»          │
│    Abstraction       │────────▶│    Implementor          │
├──────────────────────┤  tiene  ├────────────────────────┤
│ - impl: Implementor  │         │ + operationImpl(): void │
├──────────────────────┤         └───────────┬────────────┘
│ + operation(): void  │                     │
└──────────┬───────────┘            ┌────────┴────────┐
           │                        │                 │
  ┌────────┴──────────┐    ┌───────┴──────┐  ┌───────┴──────┐
  │ RefinedAbstraction │    │ ConcreteImplA│  │ ConcreteImplB│
  ├───────────────────┤    ├─────────────┤  ├─────────────┤
  │ + operation()     │    │+operationImpl│  │+operationImpl│
  └───────────────────┘    └──────────────┘  └──────────────┘

Flujo: RefinedAbstraction.operation() → impl.operationImpl()

/**
 * Implementor: define las operaciones de bajo nivel
 * para enviar mensajes por un canal específico.
 */
public interface CanalEnvio {

    /**
     * Envía un mensaje al destinatario.
     * @param destinatario dirección, número o token del receptor
     * @param mensaje      contenido del mensaje
     */
    void enviarMensaje(String destinatario, String mensaje);
}

public class CanalEmail implements CanalEnvio {

    @Override
    public void enviarMensaje(String destinatario, String mensaje) {
        System.out.println("[EMAIL] Enviando a " + destinatario);
        System.out.println("  Asunto: Notificación del sistema");
        System.out.println("  Cuerpo: " + mensaje);
        System.out.println("  --- Email enviado correctamente ---");
    }
}

public class CanalSMS implements CanalEnvio {

    @Override
    public void enviarMensaje(String destinatario, String mensaje) {
        System.out.println("[SMS] Enviando a " + destinatario);
        // Los SMS tienen límite de 160 caracteres
        String textoSMS = mensaje.length() > 160
            ? mensaje.substring(0, 157) + "..."
            : mensaje;
        System.out.println("  Texto: " + textoSMS);
        System.out.println("  --- SMS enviado correctamente ---");
    }
}

public class CanalPush implements CanalEnvio {

    @Override
    public void enviarMensaje(String destinatario, String mensaje) {
        System.out.println("[PUSH] Enviando a dispositivo: " + destinatario);
        System.out.println("  Payload: {\"alert\": \"" + mensaje + "\"}");
        System.out.println("  --- Push enviada correctamente ---");
    }
}

/**
 * Abstraction: define la interfaz de alto nivel para las
 * notificaciones. Mantiene una referencia al canal de envío
 * (Implementor) a través de composición.
 */
public abstract class Notificacion {

    // El "puente" hacia la implementación
    protected final CanalEnvio canal;

    /**
     * Constructor que recibe la implementación por inyección.
     * @param canal el canal de envío a utilizar
     */
    protected Notificacion(CanalEnvio canal) {
        this.canal = canal;
    }

    /**
     * Método de alto nivel: enviar la notificación.
     * Cada tipo de notificación define su propia lógica,
     * pero delega el envío real al canal (Implementor).
     */
    public abstract void enviar(String destinatario, String contenido);
}

public class NotificacionUrgente extends Notificacion {

    public NotificacionUrgente(CanalEnvio canal) {
        super(canal);
    }

    @Override
    public void enviar(String destinatario, String contenido) {
        String mensajeFormateado = "🚨 [URGENTE] " + contenido.toUpperCase();
        System.out.println("--- Notificación URGENTE ---");
        canal.enviarMensaje(destinatario, mensajeFormateado);
    }
}

public class NotificacionInformativa extends Notificacion {

    public NotificacionInformativa(CanalEnvio canal) {
        super(canal);
    }

    @Override
    public void enviar(String destinatario, String contenido) {
        String mensajeFormateado = "ℹ️ [INFO] " + contenido;
        System.out.println("--- Notificación informativa ---");
        canal.enviarMensaje(destinatario, mensajeFormateado);
    }
}

public class BridgeDemo {

    public static void main(String[] args) {

        // Crear implementaciones (canales)
        CanalEnvio email = new CanalEmail();
        CanalEnvio sms   = new CanalSMS();
        CanalEnvio push  = new CanalPush();

        // Combinar abstracciones con implementaciones libremente
        Notificacion urgenteEmail = new NotificacionUrgente(email);
        Notificacion urgenteSMS   = new NotificacionUrgente(sms);
        Notificacion infoEmail    = new NotificacionInformativa(email);
        Notificacion infoPush     = new NotificacionInformativa(push);

        // Usar las combinaciones
        urgenteEmail.enviar("ana@empresa.com", "Servidor caído");
        System.out.println();

        urgenteSMS.enviar("+34600123456", "Servidor caído");
        System.out.println();

        infoEmail.enviar("equipo@empresa.com", "Backup completado con éxito");
        System.out.println();

        infoPush.enviar("device-token-abc123", "Nuevo informe disponible");
    }
}

--- Notificación URGENTE ---
[EMAIL] Enviando a ana@empresa.com
  Asunto: Notificación del sistema
  Cuerpo: 🚨 [URGENTE] SERVIDOR CAÍDO
  --- Email enviado correctamente ---

--- Notificación URGENTE ---
[SMS] Enviando a +34600123456
  Texto: 🚨 [URGENTE] SERVIDOR CAÍDO
  --- SMS enviado correctamente ---

--- Notificación informativa ---
[EMAIL] Enviando a equipo@empresa.com
  Asunto: Notificación del sistema
  Cuerpo: ℹ️ [INFO] Backup completado con éxito
  --- Email enviado correctamente ---

--- Notificación informativa ---
[PUSH] Enviando a dispositivo: device-token-abc123
  Payload: {"alert": "ℹ️ [INFO] Nuevo informe disponible"}
  --- Push enviada correctamente ---

/**
 * Implementor: define las operaciones primitivas
 * que cualquier dispositivo electrónico debe soportar.
 */
public interface Dispositivo {

    boolean estaEncendido();
    void encender();
    void apagar();

    int getVolumen();
    void setVolumen(int porcentaje);

    int getCanal();
    void setCanal(int canal);

    /** Información del dispositivo para diagnóstico */
    String getNombre();
}

public class Television implements Dispositivo {

    private boolean encendido = false;
    private int volumen = 30;
    private int canal = 1;

    @Override public boolean estaEncendido() { return encendido; }
    @Override public void encender()  { encendido = true;  }
    @Override public void apagar()    { encendido = false; }

    @Override public int getVolumen() { return volumen; }
    @Override public void setVolumen(int porcentaje) {
        this.volumen = Math.max(0, Math.min(100, porcentaje));
    }

    @Override public int getCanal() { return canal; }
    @Override public void setCanal(int canal) {
        this.canal = Math.max(1, canal);
    }

    @Override public String getNombre() { return "Televisión Samsung 55\""; }
}

public class Radio implements Dispositivo {

    private boolean encendido = false;
    private int volumen = 20;
    private int emisora = 88; // FM 88.0

    @Override public boolean estaEncendido() { return encendido; }
    @Override public void encender()  { encendido = true;  }
    @Override public void apagar()    { encendido = false; }

    @Override public int getVolumen() { return volumen; }
    @Override public void setVolumen(int porcentaje) {
        this.volumen = Math.max(0, Math.min(100, porcentaje));
    }

    @Override public int getCanal() { return emisora; }
    @Override public void setCanal(int canal) {
        this.emisora = Math.max(88, Math.min(108, canal));
    }

    @Override public String getNombre() { return "Radio FM Digital"; }
}

/**
 * Abstraction: control remoto básico.
 * Mantiene referencia al dispositivo (Implementor)
 * y define operaciones de alto nivel.
 */
public class ControlRemoto {

    protected final Dispositivo dispositivo;

    public ControlRemoto(Dispositivo dispositivo) {
        this.dispositivo = dispositivo;
    }

    public void toggleEncendido() {
        if (dispositivo.estaEncendido()) {
            dispositivo.apagar();
            System.out.println(dispositivo.getNombre() + " → APAGADO");
        } else {
            dispositivo.encender();
            System.out.println(dispositivo.getNombre() + " → ENCENDIDO");
        }
    }

    public void subirVolumen() {
        dispositivo.setVolumen(dispositivo.getVolumen() + 10);
        System.out.println("Volumen: " + dispositivo.getVolumen());
    }

    public void bajarVolumen() {
        dispositivo.setVolumen(dispositivo.getVolumen() - 10);
        System.out.println("Volumen: " + dispositivo.getVolumen());
    }

    public void canalArriba() {
        dispositivo.setCanal(dispositivo.getCanal() + 1);
        System.out.println("Canal: " + dispositivo.getCanal());
    }

    public void canalAbajo() {
        dispositivo.setCanal(dispositivo.getCanal() - 1);
        System.out.println("Canal: " + dispositivo.getCanal());
    }
}

/**
 * RefinedAbstraction: añade funciones extra como
 * silenciar y mostrar estado detallado del dispositivo.
 */
public class ControlRemotoAvanzado extends ControlRemoto {

    private int volumenAnterior = -1;

    public ControlRemotoAvanzado(Dispositivo dispositivo) {
        super(dispositivo);
    }

    /** Silencia el dispositivo o restaura el volumen anterior */
    public void silenciar() {
        if (volumenAnterior < 0) {
            volumenAnterior = dispositivo.getVolumen();
            dispositivo.setVolumen(0);
            System.out.println("🔇 Silenciado (volumen anterior: " + volumenAnterior + ")");
        } else {
            dispositivo.setVolumen(volumenAnterior);
            System.out.println("🔊 Volumen restaurado a " + volumenAnterior);
            volumenAnterior = -1;
        }
    }

    /** Muestra el estado completo del dispositivo */
    public void mostrarEstado() {
        System.out.println("┌──────────────────────────────┐");
        System.out.println("│ Dispositivo: " + dispositivo.getNombre());
        System.out.println("│ Estado:      " + (dispositivo.estaEncendido() ? "Encendido" : "Apagado"));
        System.out.println("│ Volumen:     " + dispositivo.getVolumen() + "%");
        System.out.println("│ Canal:       " + dispositivo.getCanal());
        System.out.println("└──────────────────────────────┘");
    }
}

public class DispositivosDemo {

    public static void main(String[] args) {

        // Control básico → Televisión
        System.out.println("=== Control básico + TV ===");
        ControlRemoto controlTV = new ControlRemoto(new Television());
        controlTV.toggleEncendido();
        controlTV.subirVolumen();
        controlTV.canalArriba();

        System.out.println();

        // Control avanzado → Radio
        System.out.println("=== Control avanzado + Radio ===");
        ControlRemotoAvanzado controlRadio =
            new ControlRemotoAvanzado(new Radio());
        controlRadio.toggleEncendido();
        controlRadio.subirVolumen();
        controlRadio.silenciar();
        controlRadio.silenciar();  // Restaurar
        controlRadio.mostrarEstado();
    }
}

// Tu código (usa la abstracción) — NO cambia al cambiar de BD
Connection conn = DriverManager.getConnection(
    "jdbc:mysql://localhost:3306/tienda", "usuario", "clave"
);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM productos");

// Para cambiar de MySQL a PostgreSQL, solo cambias la URL:
// "jdbc:postgresql://localhost:5432/tienda"
// El resto del código permanece EXACTAMENTE igual.
// Eso es Bridge en acción.