Desafíos de Interfaces

Checkout con múltiples medios de pago. El contrato es el mismo, la implementación cambia.

Qué hacer: Define la interfaz Pagable con pagar(monto) y generarComprobante(). Implementa PagoTarjeta, PagoTransferencia y PagoEfectivo con validaciones propias.

// 1. Declaración de la Interfaz
public interface Pagable {
    public  pagar(monto: double): boolean;
    public  generarComprobante(): String;
}


// 3. Clases Implementadoras
public class PagoTarjeta implements Pagable {
    private numero_tarjeta: String;
    private cvv: String;
    private fecha_expiracion: String;
    @Override
    public  pagar(monto: double): boolean {
        System.out.println("Ejecutando PagoTarjeta...");
    }
}

public class PagoTransferencia implements Pagable {
    private banco: String;
    private cuenta_destino: String;
    @Override
    public  pagar(monto: double): boolean {
        System.out.println("Ejecutando PagoTransferencia...");
    }
}

public class PagoEfectivo implements Pagable {
    private monto_recibido: double;
    private caja_id: String;
    @Override
    public  pagar(monto: double): boolean {
        System.out.println("Ejecutando PagoEfectivo...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Pagable[] objetos = {
            new PagoTarjeta(),
            new PagoTransferencia(),
            new PagoEfectivo()
        };
        for (Pagable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Sistema omnichannel: email, SMS y push comparten el envío pero validan distinto.

Qué hacer: Implementa Notificable con enviar(mensaje) y validarDestino(). Cada implementación debe validar su destino antes de enviar.

// 1. Declaración de la Interfaz
public interface Notificable {
    public  enviar(mensaje: String): boolean;
    public  validarDestino(): boolean;
}


// 3. Clases Implementadoras
public class NotificacionEmail implements Notificable {
    private email: String;
    private asunto: String;
    @Override
    public  enviar(mensaje: String): boolean {
        System.out.println("Ejecutando NotificacionEmail...");
    }
}

public class NotificacionSMS implements Notificable {
    private telefono: String;
    private operador: String;
    @Override
    public  enviar(mensaje: String): boolean {
        System.out.println("Ejecutando NotificacionSMS...");
    }
}

public class NotificacionPush implements Notificable {
    private device_token: String;
    private plataforma: String;
    @Override
    public  enviar(mensaje: String): boolean {
        System.out.println("Ejecutando NotificacionPush...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Notificable[] objetos = {
            new NotificacionEmail(),
            new NotificacionSMS(),
            new NotificacionPush()
        };
        for (Notificable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Torre de control que opera cualquier cosa que vuele con el mismo contrato.

Qué hacer: Define Volador con despegar(), aterrizar() y obtenerAltitud(). Avion, Dron y Pajaro implementan distinto.

// 1. Declaración de la Interfaz
public interface Volador {
    public  despegar(): void;
    public  aterrizar(): void;
    public  obtenerAltitud(): double;
}


// 3. Clases Implementadoras
public class Avion implements Volador {
    private aerolinea: String;
    private capacidad_pasajeros: int;
    @Override
    public  despegar(): void {
        System.out.println("Ejecutando Avion...");
    }
}

public class Dron implements Volador {
    private bateria_porcentaje: int;
    private alcance_metros: double;
    @Override
    public  despegar(): void {
        System.out.println("Ejecutando Dron...");
    }
}

public class Pajaro implements Volador {
    private especie: String;
    private envergadura_alas: double;
    @Override
    public  despegar(): void {
        System.out.println("Ejecutando Pajaro...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Volador[] objetos = {
            new Avion(),
            new Dron(),
            new Pajaro()
        };
        for (Volador obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Player que reproduce audio, video o podcast con controles idénticos.

Qué hacer: Contrato Reproducible con reproducir(), pausar() y detener(). Cada media maneja buffering distinto.

// 1. Declaración de la Interfaz
public interface Reproducible {
    public  reproducir(): void;
    public  pausar(): void;
    public  detener(): void;
}


// 3. Clases Implementadoras
public class Audio implements Reproducible {
    private duracion_segundos: int;
    private bitrate: int;
    @Override
    public  reproducir(): void {
        System.out.println("Ejecutando Audio...");
    }
}

public class Video implements Reproducible {
    private resolucion: String;
    private fps: int;
    @Override
    public  reproducir(): void {
        System.out.println("Ejecutando Video...");
    }
}

public class Podcast implements Reproducible {
    private episodio: int;
    private anfitrion: String;
    @Override
    public  reproducir(): void {
        System.out.println("Ejecutando Podcast...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Reproducible[] objetos = {
            new Audio(),
            new Video(),
            new Podcast()
        };
        for (Reproducible obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Login con email, biometría y SSO comparten el mismo flujo de autenticación.

Qué hacer: Define Autenticable con autenticar(credenciales) y cerrarSesion(). Implementa las 3 variantes con validación propia.

// 1. Declaración de la Interfaz
public interface Autenticable {
    public  autenticar(credenciales: String): boolean;
    public  cerrarSesion(): void;
}


// 3. Clases Implementadoras
public class LoginEmail implements Autenticable {
    private email: String;
    private password_hash: String;
    @Override
    public  autenticar(credenciales: String): boolean {
        System.out.println("Ejecutando LoginEmail...");
    }
}

public class LoginBiometrico implements Autenticable {
    private huella_id: String;
    private dispositivo: String;
    @Override
    public  autenticar(credenciales: String): boolean {
        System.out.println("Ejecutando LoginBiometrico...");
    }
}

public class LoginSSO implements Autenticable {
    private proveedor: String;
    private token_oauth: String;
    @Override
    public  autenticar(credenciales: String): boolean {
        System.out.println("Ejecutando LoginSSO...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Autenticable[] objetos = {
            new LoginEmail(),
            new LoginBiometrico(),
            new LoginSSO()
        };
        for (Autenticable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Marketplace que alquila autos, deptos y bicis con cálculo de costo distinto.

Qué hacer: Contrato Alquilable con calcularCosto(dias) y reservar(fecha). Cada implementación aplica tarifa propia.

// 1. Declaración de la Interfaz
public interface Alquilable {
    public  calcularCosto(dias: int): double;
    public  reservar(fecha: String): boolean;
}


// 3. Clases Implementadoras
public class AutoAlquiler implements Alquilable {
    private patente: String;
    private categoria: String;
    @Override
    public  calcularCosto(dias: int): double {
        System.out.println("Ejecutando AutoAlquiler...");
    }
}

public class Departamento implements Alquilable {
    private direccion: String;
    private capacidad_personas: int;
    @Override
    public  calcularCosto(dias: int): double {
        System.out.println("Ejecutando Departamento...");
    }
}

public class Bicicleta implements Alquilable {
    private rodado: int;
    private tipo: String;
    @Override
    public  calcularCosto(dias: int): double {
        System.out.println("Ejecutando Bicicleta...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Alquilable[] objetos = {
            new AutoAlquiler(),
            new Departamento(),
            new Bicicleta()
        };
        for (Alquilable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Módulo de reportes que exporta a PDF, Excel o CSV validando datos igual.

Qué hacer: Define Exportable con exportar(formato) y validarDatos(). Cada formato serializa distinto.

// 1. Declaración de la Interfaz
public interface Exportable {
    public  exportar(formato: String): String;
    public  validarDatos(): boolean;
}


// 3. Clases Implementadoras
public class ReportePDF implements Exportable {
    private orientacion: String;
    private incluye_graficos: boolean;
    @Override
    public  exportar(formato: String): String {
        System.out.println("Ejecutando ReportePDF...");
    }
}

public class ReporteExcel implements Exportable {
    private hoja: String;
    private incluye_formulas: boolean;
    @Override
    public  exportar(formato: String): String {
        System.out.println("Ejecutando ReporteExcel...");
    }
}

public class ReporteCSV implements Exportable {
    private delimitador: String;
    private encoding: String;
    @Override
    public  exportar(formato: String): String {
        System.out.println("Ejecutando ReporteCSV...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Exportable[] objetos = {
            new ReportePDF(),
            new ReporteExcel(),
            new ReporteCSV()
        };
        for (Exportable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Mapa en tiempo real de paquetes, vehículos y personas con el mismo contrato de ubicación.

Qué hacer: Contrato Rastreable con obtenerUbicacion() y actualizarUbicacion(lat,lng). Simula movimiento de cada tipo.

// 1. Declaración de la Interfaz
public interface Rastreable {
    public  obtenerUbicacion(): String;
    public  actualizarUbicacion(lat: double, lng: double): void;
}


// 3. Clases Implementadoras
public class Paquete implements Rastreable {
    private codigo_seguimiento: String;
    private estado: String;
    @Override
    public  obtenerUbicacion(): String {
        System.out.println("Ejecutando Paquete...");
    }
}

public class VehiculoFlota implements Rastreable {
    private patente: String;
    private chofer: String;
    @Override
    public  obtenerUbicacion(): String {
        System.out.println("Ejecutando VehiculoFlota...");
    }
}

public class PersonaRastreable implements Rastreable {
    private rut: String;
    private nombre: String;
    @Override
    public  obtenerUbicacion(): String {
        System.out.println("Ejecutando PersonaRastreable...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Rastreable[] objetos = {
            new Paquete(),
            new VehiculoFlota(),
            new PersonaRastreable()
        };
        for (Rastreable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Carrito que aplica descuentos a productos, servicios y suscripciones con reglas distintas.

Qué hacer: Define Descontable con aplicarDescuento(porcentaje) y obtenerPrecioFinal(). Cada tipo calcula distinto.

// 1. Declaración de la Interfaz
public interface Descontable {
    public  aplicarDescuento(porcentaje: double): void;
    public  obtenerPrecioFinal(): double;
}


// 3. Clases Implementadoras
public class Producto implements Descontable {
    private sku: String;
    private stock: int;
    @Override
    public  aplicarDescuento(porcentaje: double): void {
        System.out.println("Ejecutando Producto...");
    }
}

public class Servicio implements Descontable {
    private horas_estimadas: double;
    private tarifa_hora: double;
    @Override
    public  aplicarDescuento(porcentaje: double): void {
        System.out.println("Ejecutando Servicio...");
    }
}

public class SuscripcionDescontable implements Descontable {
    private plan: String;
    private meses_restantes: int;
    @Override
    public  aplicarDescuento(porcentaje: double): void {
        System.out.println("Ejecutando SuscripcionDescontable...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Descontable[] objetos = {
            new Producto(),
            new Servicio(),
            new SuscripcionDescontable()
        };
        for (Descontable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Formularios que validan email, RUT y teléfono con el mismo contrato pero regex distintas.

Qué hacer: Contrato Validador con validar(dato) y obtenerMensajeError(). Implementa ValidadorEmail, ValidadorRut y ValidadorTelefono.

// 1. Declaración de la Interfaz
public interface Validador {
    public  validar(dato: String): boolean;
    public  obtenerMensajeError(): String;
}


// 3. Clases Implementadoras
public class ValidadorEmail implements Validador {
    private regex_email: String;
    @Override
    public  validar(dato: String): boolean {
        System.out.println("Ejecutando ValidadorEmail...");
    }
}

public class ValidadorRut implements Validador {
    private digito_verificador: String;
    @Override
    public  validar(dato: String): boolean {
        System.out.println("Ejecutando ValidadorRut...");
    }
}

public class ValidadorTelefono implements Validador {
    private codigo_pais: String;
    private largo_minimo: int;
    @Override
    public  validar(dato: String): boolean {
        System.out.println("Ejecutando ValidadorTelefono...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Validador[] objetos = {
            new ValidadorEmail(),
            new ValidadorRut(),
            new ValidadorTelefono()
        };
        for (Validador obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Hub IoT que conecta sensores WiFi, Bluetooth y APIs REST con el mismo ciclo de vida.

Qué hacer: Define Conectable con conectar(), desconectar() y enviarDatos(payload). Simula conexión de cada dispositivo.

// 1. Declaración de la Interfaz
public interface Conectable {
    public  conectar(): boolean;
    public  desconectar(): void;
    public  enviarDatos(payload: String): boolean;
}


// 3. Clases Implementadoras
public class SensorWifi implements Conectable {
    private ssid: String;
    private rssi: int;
    @Override
    public  conectar(): boolean {
        System.out.println("Ejecutando SensorWifi...");
    }
}

public class BluetoothDevice implements Conectable {
    private mac_address: String;
    private version_bt: String;
    @Override
    public  conectar(): boolean {
        System.out.println("Ejecutando BluetoothDevice...");
    }
}

public class ApiRest implements Conectable {
    private endpoint: String;
    private api_key: String;
    @Override
    public  conectar(): boolean {
        System.out.println("Ejecutando ApiRest...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Conectable[] objetos = {
            new SensorWifi(),
            new BluetoothDevice(),
            new ApiRest()
        };
        for (Conectable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Punto de venta que imprime facturas, tickets y etiquetas con vista previa idéntica.

Qué hacer: Contrato Imprimible con imprimir() y vistaPrevia(). Cada documento renderiza distinto.

// 1. Declaración de la Interfaz
public interface Imprimible {
    public  imprimir(): boolean;
    public  vistaPrevia(): String;
}


// 3. Clases Implementadoras
public class FacturaImprimible implements Imprimible {
    private folio: int;
    private iva: double;
    @Override
    public  imprimir(): boolean {
        System.out.println("Ejecutando FacturaImprimible...");
    }
}

public class Ticket implements Imprimible {
    private numero: int;
    private caja: String;
    @Override
    public  imprimir(): boolean {
        System.out.println("Ejecutando Ticket...");
    }
}

public class Etiqueta implements Imprimible {
    private codigo_barras: String;
    private tamano: String;
    @Override
    public  imprimir(): boolean {
        System.out.println("Ejecutando Etiqueta...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Imprimible[] objetos = {
            new FacturaImprimible(),
            new Ticket(),
            new Etiqueta()
        };
        for (Imprimible obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Buscador universal para catálogo, biblioteca y directorio con filtros propios.

Qué hacer: Define Buscable con buscar(query) y filtrar(criterio). Cada implementación filtra distinto.

// 1. Declaración de la Interfaz
public interface Buscable {
    public  buscar(query: String): List;
    public  filtrar(criterio: String): List;
}


// 3. Clases Implementadoras
public class CatalogoProductos implements Buscable {
    private categoria: String;
    private precio_min: double;
    @Override
    public  buscar(query: String): List {
        System.out.println("Ejecutando CatalogoProductos...");
    }
}

public class Biblioteca implements Buscable {
    private isbn: String;
    private autor: String;
    @Override
    public  buscar(query: String): List {
        System.out.println("Ejecutando Biblioteca...");
    }
}

public class DirectorioUsuarios implements Buscable {
    private rol: String;
    private activo: boolean;
    @Override
    public  buscar(query: String): List {
        System.out.println("Ejecutando DirectorioUsuarios...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Buscable[] objetos = {
            new CatalogoProductos(),
            new Biblioteca(),
            new DirectorioUsuarios()
        };
        for (Buscable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Capa de caché con memoria, Redis y disco compartiendo get/set/expire.

Qué hacer: Contrato Cacheable con guardar(clave,valor), obtener(clave) y expirar(clave). Simula TTL distinto por backend.

// 1. Declaración de la Interfaz
public interface Cacheable {
    public  guardar(clave: String, valor: String): boolean;
    public  obtener(clave: String): String;
    public  expirar(clave: String): boolean;
}


// 3. Clases Implementadoras
public class CacheMemoria implements Cacheable {
    private max_items: int;
    private politica_eviction: String;
    @Override
    public  guardar(clave: String, valor: String): boolean {
        System.out.println("Ejecutando CacheMemoria...");
    }
}

public class CacheRedis implements Cacheable {
    private host: String;
    private puerto: int;
    @Override
    public  guardar(clave: String, valor: String): boolean {
        System.out.println("Ejecutando CacheRedis...");
    }
}

public class CacheDisco implements Cacheable {
    private ruta: String;
    private compresion: boolean;
    @Override
    public  guardar(clave: String, valor: String): boolean {
        System.out.println("Ejecutando CacheDisco...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Cacheable[] objetos = {
            new CacheMemoria(),
            new CacheRedis(),
            new CacheDisco()
        };
        for (Cacheable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}

Runner que ejecuta tests unitarios, de integración y E2E con el mismo ciclo.

Qué hacer: Define Testeable con ejecutarTest() y generarReporte(). Cada tipo de test reporta distinto.

// 1. Declaración de la Interfaz
public interface Testeable {
    public  ejecutarTest(): boolean;
    public  generarReporte(): String;
}


// 3. Clases Implementadoras
public class TestUnitario implements Testeable {
    private clase_objetivo: String;
    private mocks: int;
    @Override
    public  ejecutarTest(): boolean {
        System.out.println("Ejecutando TestUnitario...");
    }
}

public class TestIntegracion implements Testeable {
    private base_datos: String;
    private fixtures: String;
    @Override
    public  ejecutarTest(): boolean {
        System.out.println("Ejecutando TestIntegracion...");
    }
}

public class TestE2E implements Testeable {
    private url: String;
    private navegador: String;
    @Override
    public  ejecutarTest(): boolean {
        System.out.println("Ejecutando TestE2E...");
    }
}

// 4. Ejemplo de prueba en Main
public class Main {
    public static void main(String[] args) {
        Testeable[] objetos = {
            new TestUnitario(),
            new TestIntegracion(),
            new TestE2E()
        };
        for (Testeable obj : objetos) {
            System.out.println(obj.toString());
        }
    }
}