Desafíos de Herencia

Un campus digital necesita un modelo único de persona, con roles que especializan el acceso.

Qué hacer: Implementa la jerarquía. Instancia un estudiante, un docente y un administrativo, y llama al menos un método heredado y uno propio.

// 1. Clase Padre / Base
public class Persona {
    private rut: String;
    private nombre: String;
    private email: String;

    public Persona() {}

    public iniciar_sesion(): void {
        System.out.println("Ejecutando iniciar_sesion(): void en Persona...");
    }
}


// 2. Clases Hijas
public class Estudiante extends Persona {
    private matricula: String;
    private promedio_notas: double;
    @Override
    public iniciar_sesion(): void {
        System.out.println("Comportamiento especializado en Estudiante");
    }
}

public class Docente extends Persona {
    private codigo_profesor: String;
    private departamento: String;
    @Override
    public iniciar_sesion(): void {
        System.out.println("Comportamiento especializado en Docente");
    }
}

public class Administrativo extends Persona {
    private cargo: String;
    private horario_turno: String;
    @Override
    public iniciar_sesion(): void {
        System.out.println("Comportamiento especializado en Administrativo");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Persona[] lista = {
            new Estudiante(),
            new Docente(),
            new Administrativo()
        };
        for (Persona obj : lista) {
            obj.iniciar_sesion();
        }
    }
}

Una empresa de courier comparte el ciclo de vida del envío, pero cada modalidad tiene reglas distintas.

Qué hacer: Modela la herencia. Crea un arreglo (o lista) de tipo Envio con las tres hijas y recórrelo llamando actualizar_estado().

// 1. Clase Padre / Base
public class Envio {
    private codigo_seguimiento: String;
    private remitente: String;
    private destinatario: String;

    public Envio() {}

    public actualizar_estado(): void {
        System.out.println("Ejecutando actualizar_estado(): void en Envio...");
    }
}


// 2. Clases Hijas
public class EnvioEstandar extends Envio {
    private dias_habiles_entrega: int;
    @Override
    public actualizar_estado(): void {
        System.out.println("Comportamiento especializado en EnvioEstandar");
    }
}

public class EnvioExpress extends Envio {
    private garantia_mismo_dia: boolean;
    private recargo_urgencia: double;
    @Override
    public actualizar_estado(): void {
        System.out.println("Comportamiento especializado en EnvioExpress");
    }
}

public class EnvioInternacional extends Envio {
    private pais_destino: String;
    private impuesto_aduanero: double;
    @Override
    public actualizar_estado(): void {
        System.out.println("Comportamiento especializado en EnvioInternacional");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Envio[] lista = {
            new EnvioEstandar(),
            new EnvioExpress(),
            new EnvioInternacional()
        };
        for (Envio obj : lista) {
            obj.actualizar_estado();
        }
    }
}

El sistema de autenticación comparte credenciales, pero cada rol tiene privilegios distintos.

Qué hacer: Implementa las tres cuentas. El administrador debe poder bloquear a un usuario registrado (simúlalo con un método).

// 1. Clase Padre / Base
public class Usuario {
    private username: String;
    private password: String;
    private ultimo_acceso: String;

    public Usuario() {}

    public autenticar(): boolean {
        System.out.println("Ejecutando autenticar(): boolean en Usuario...");
    }
}


// 2. Clases Hijas
public class UsuarioInvitado extends Usuario {
    private tiempo_expiracion_sesion: int;
    @Override
    public autenticar(): boolean {
        System.out.println("Comportamiento especializado en UsuarioInvitado");
    }
}

public class UsuarioRegistrado extends Usuario {
    private historial_actividad: String;
    private avatar_url: String;
    @Override
    public autenticar(): boolean {
        System.out.println("Comportamiento especializado en UsuarioRegistrado");
    }
}

public class UsuarioAdministrador extends Usuario {
    private nivel_acceso: int;
    @Override
    public autenticar(): boolean {
        System.out.println("Comportamiento especializado en UsuarioAdministrador");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Usuario[] lista = {
            new UsuarioInvitado(),
            new UsuarioRegistrado(),
            new UsuarioAdministrador()
        };
        for (Usuario obj : lista) {
            obj.autenticar();
        }
    }
}

En la barra todas las bebidas se preparan, pero cada receta tiene insumos y pasos extra.

Qué hacer: Sobrescribe preparar() en cada hija (polimorfismo). En Cafe agrega agregar_shot_espresso().

// 1. Clase Padre / Base
public class Bebida {
    private nombre: String;
    private tamano_ml: int;
    private temperatura: String;

    public Bebida() {}

    public preparar(): void {
        System.out.println("Ejecutando preparar(): void en Bebida...");
    }
}


// 2. Clases Hijas
public class Cafe extends Bebida {
    private tipo_grano: String;
    private nivel_tueste: String;
    @Override
    public preparar(): void {
        System.out.println("Comportamiento especializado en Cafe");
    }
}

public class Te extends Bebida {
    private variedad_hoja: String;
    private tiempo_infusion: int;
    @Override
    public preparar(): void {
        System.out.println("Comportamiento especializado en Te");
    }
}

public class JugoNatural extends Bebida {
    private fruta_principal: String;
    private tiene_azucar_anadida: boolean;
    @Override
    public preparar(): void {
        System.out.println("Comportamiento especializado en JugoNatural");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Bebida[] lista = {
            new Cafe(),
            new Te(),
            new JugoNatural()
        };
        for (Bebida obj : lista) {
            obj.preparar();
        }
    }
}

Una plataforma de streaming cobra distinto según el plan, pero todos se renuevan.

Qué hacer: Implementa renovar() en la base. Cada plan debe imprimir un resumen de beneficios al renovar.

// 1. Clase Padre / Base
public class Suscripcion {
    private id_cliente: String;
    private costo_mensual: double;
    private estado: String;

    public Suscripcion() {}

    public renovar(): boolean {
        System.out.println("Ejecutando renovar(): boolean en Suscripcion...");
    }
}


// 2. Clases Hijas
public class PlanGratuito extends Suscripcion {
    private limite_anuncios_por_hora: int;
    @Override
    public renovar(): boolean {
        System.out.println("Comportamiento especializado en PlanGratuito");
    }
}

public class PlanIndividual extends Suscripcion {
    private calidad_streaming_hd: boolean;
    @Override
    public renovar(): boolean {
        System.out.println("Comportamiento especializado en PlanIndividual");
    }
}

public class PlanFamiliar extends Suscripcion {
    private max_perfiles_simultaneos: int;
    private control_parental: boolean;
    @Override
    public renovar(): boolean {
        System.out.println("Comportamiento especializado en PlanFamiliar");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Suscripcion[] lista = {
            new PlanGratuito(),
            new PlanIndividual(),
            new PlanFamiliar()
        };
        for (Suscripcion obj : lista) {
            obj.renovar();
        }
    }
}

El inventario del taller comparte nombre y peso, pero el uso cambia si es manual, eléctrica o de medición.

Qué hacer: Llama utilizar() de forma polimórfica. Las hijas con métodos extra (aplicar_fuerza, cambiar_velocidad) deben usarlos al menos una vez.

// 1. Clase Padre / Base
public class Herramienta {
    private nombre: String;
    private material: String;
    private peso_gramos: double;

    public Herramienta() {}

    public utilizar(): void {
        System.out.println("Ejecutando utilizar(): void en Herramienta...");
    }
}


// 2. Clases Hijas
public class HerramientaManual extends Herramienta {
    private tipo_mango: String;
    @Override
    public utilizar(): void {
        System.out.println("Comportamiento especializado en HerramientaManual");
    }
}

public class HerramientaElectrica extends Herramienta {
    private voltaje: int;
    private consumo_watts: int;
    @Override
    public utilizar(): void {
        System.out.println("Comportamiento especializado en HerramientaElectrica");
    }
}

public class HerramientaMedicion extends Herramienta {
    private unidad_medida: String;
    private margen_error: double;
    @Override
    public utilizar(): void {
        System.out.println("Comportamiento especializado en HerramientaMedicion");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Herramienta[] lista = {
            new HerramientaManual(),
            new HerramientaElectrica(),
            new HerramientaMedicion()
        };
        for (Herramienta obj : lista) {
            obj.utilizar();
        }
    }
}

La ficha clínica es común; la biología (pelo, alas, escamas) especializa el cuidado.

Qué hacer: Crea un zoológico (colección de Animal) con un mamífero, un ave y un reptil. Alimenta a todos recorriendo la colección.

// 1. Clase Padre / Base
public class Animal {
    private chip_id: String;
    private especie: String;
    private edad: int;
    private peso: double;

    public Animal() {}

    public alimentar(): void {
        System.out.println("Ejecutando alimentar(): void en Animal...");
    }
}


// 2. Clases Hijas
public class Mamifero extends Animal {
    private tipo_pelaje: String;
    private periodo_gestacion: int;
    @Override
    public alimentar(): void {
        System.out.println("Comportamiento especializado en Mamifero");
    }
}

public class Ave extends Animal {
    private envergadura_alas: double;
    private puede_volar: boolean;
    @Override
    public alimentar(): void {
        System.out.println("Comportamiento especializado en Ave");
    }
}

public class Reptil extends Animal {
    private temperatura_corporal_optima: double;
    private tipo_escama: String;
    @Override
    public alimentar(): void {
        System.out.println("Comportamiento especializado en Reptil");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Animal[] lista = {
            new Mamifero(),
            new Ave(),
            new Reptil()
        };
        for (Animal obj : lista) {
            obj.alimentar();
        }
    }
}

Todos los tickets se cierran igual, pero el origen del caso cambia los datos que se guardan.

Qué hacer: Implementa cerrar_caso() en la base. Instancia un ticket de cada canal y ciérralos.

// 1. Clase Padre / Base
public class CanalAtencion {
    private id_ticket: String;
    private fecha_creacion: String;

    public CanalAtencion() {}

    public cerrar_caso(): void {
        System.out.println("Ejecutando cerrar_caso(): void en CanalAtencion...");
    }
}


// 2. Clases Hijas
public class TicketWeb extends CanalAtencion {
    private ip_usuario: String;
    private navegador: String;
    @Override
    public cerrar_caso(): void {
        System.out.println("Comportamiento especializado en TicketWeb");
    }
}

public class LlamadaTelefonica extends CanalAtencion {
    private numero_origen: String;
    private grabacion_llamada_url: String;
    @Override
    public cerrar_caso(): void {
        System.out.println("Comportamiento especializado en LlamadaTelefonica");
    }
}

public class ChatBot extends CanalAtencion {
    private intencion_detectada: String;
    private transferido_a_humano: boolean;
    @Override
    public cerrar_caso(): void {
        System.out.println("Comportamiento especializado en ChatBot");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        CanalAtencion[] lista = {
            new TicketWeb(),
            new LlamadaTelefonica(),
            new ChatBot()
        };
        for (CanalAtencion obj : lista) {
            obj.cerrar_caso();
        }
    }
}

El combate comparte atacar(), pero cada familia de arma tiene mecánicas extra.

Qué hacer: Sobrescribe atacar() en cada hija. Usa bloquear() y recargar() desde el tipo concreto (no solo desde Arma).

// 1. Clase Padre / Base
public class Arma {
    private nombre: String;
    private peso: double;
    private durabilidad: int;

    public Arma() {}

    public atacar(): int {
        System.out.println("Ejecutando atacar(): int en Arma...");
    }
}


// 2. Clases Hijas
public class ArmaCuerpoACuerpo extends Arma {
    private filo_ataque: int;
    @Override
    public atacar(): int {
        System.out.println("Comportamiento especializado en ArmaCuerpoACuerpo");
    }
}

public class ArmaFuego extends Arma {
    private calibre: String;
    private capacidad_cargador: int;
    @Override
    public atacar(): int {
        System.out.println("Comportamiento especializado en ArmaFuego");
    }
}

public class ArmaMagica extends Arma {
    private costo_mana: int;
    private tipo_elemento: String;
    @Override
    public atacar(): int {
        System.out.println("Comportamiento especializado en ArmaMagica");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Arma[] lista = {
            new ArmaCuerpoACuerpo(),
            new ArmaFuego(),
            new ArmaMagica()
        };
        for (Arma obj : lista) {
            obj.atacar();
        }
    }
}

Una red de sensores comparte identidad y batería; cada tipo lee un fenómeno distinto.

Qué hacer: Implementa leer_dato() (puedes devolver un número simulado). El de movimiento y el de humo deben usar sus métodos de alerta.

// 1. Clase Padre / Base
public class Sensor {
    private id_dispositivo: String;
    private ubicacion: String;
    private bateria_porcentaje: int;

    public Sensor() {}

    public leer_dato(): double {
        System.out.println("Ejecutando leer_dato(): double en Sensor...");
    }
}


// 2. Clases Hijas
public class SensorTemperatura extends Sensor {
    private escala_celsius: boolean;
    private rango_maximo: double;
    @Override
    public leer_dato(): double {
        System.out.println("Comportamiento especializado en SensorTemperatura");
    }
}

public class SensorMovimiento extends Sensor {
    private rango_vision_metros: double;
    @Override
    public leer_dato(): double {
        System.out.println("Comportamiento especializado en SensorMovimiento");
    }
}

public class SensorHumo extends Sensor {
    private umbral_alarma_ppm: int;
    @Override
    public leer_dato(): double {
        System.out.println("Comportamiento especializado en SensorHumo");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Sensor[] lista = {
            new SensorTemperatura(),
            new SensorMovimiento(),
            new SensorHumo()
        };
        for (Sensor obj : lista) {
            obj.leer_dato();
        }
    }
}

La carta marca disponibilidad de la misma forma; entrada, fondo y postre aportan datos de servicio.

Qué hacer: Crea un menú del día con un plato de cada tipo y marca todos como disponibles.

// 1. Clase Padre / Base
public class Plato {
    private nombre: String;
    private precio: double;
    private tiempo_coccion_min: int;

    public Plato() {}

    public marcar_disponible(): void {
        System.out.println("Ejecutando marcar_disponible(): void en Plato...");
    }
}


// 2. Clases Hijas
public class Entrada extends Plato {
    private es_fria: boolean;
    private para_compartir: boolean;
    @Override
    public marcar_disponible(): void {
        System.out.println("Comportamiento especializado en Entrada");
    }
}

public class PlatoFondo extends Plato {
    private guarnicion_incluida: String;
    private punto_coccion: String;
    @Override
    public marcar_disponible(): void {
        System.out.println("Comportamiento especializado en PlatoFondo");
    }
}

public class Postre extends Plato {
    private calorias: int;
    private es_sin_azucar: boolean;
    @Override
    public marcar_disponible(): void {
        System.out.println("Comportamiento especializado en Postre");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Plato[] lista = {
            new Entrada(),
            new PlatoFondo(),
            new Postre()
        };
        for (Plato obj : lista) {
            obj.marcar_disponible();
        }
    }
}

Patrullas, ambulancias y carros bomba salen de una misma flota operativa.

Qué hacer: Enciende la sirena de los tres vehículos desde una lista de VehiculoEmergencia (polimorfismo).

// 1. Clase Padre / Base
public class VehiculoEmergencia {
    private patente: String;
    private base_operativa: String;

    public VehiculoEmergencia() {}

    public encender_sirena(): void {
        System.out.println("Ejecutando encender_sirena(): void en VehiculoEmergencia...");
    }
}


// 2. Clases Hijas
public class Ambulancia extends VehiculoEmergencia {
    private equipamiento_uci: boolean;
    private personal_medico_a_bordo: int;
    @Override
    public encender_sirena(): void {
        System.out.println("Comportamiento especializado en Ambulancia");
    }
}

public class CarroBomba extends VehiculoEmergencia {
    private capacidad_estanque_agua: double;
    private largo_escala: double;
    @Override
    public encender_sirena(): void {
        System.out.println("Comportamiento especializado en CarroBomba");
    }
}

public class PatrullaPolicial extends VehiculoEmergencia {
    private camara_abordo: boolean;
    private blindaje_nivel: int;
    @Override
    public encender_sirena(): void {
        System.out.println("Comportamiento especializado en PatrullaPolicial");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        VehiculoEmergencia[] lista = {
            new Ambulancia(),
            new CarroBomba(),
            new PatrullaPolicial()
        };
        for (VehiculoEmergencia obj : lista) {
            obj.encender_sirena();
        }
    }
}

Un tablero Kanban trata todo como Tarea, pero bugs, features y mantenimiento no se estiman igual.

Qué hacer: Completa una tarea de cada tipo. Imprime título, estado y el dato específico de la hija.

// 1. Clase Padre / Base
public class Tarea {
    private titulo: String;
    private fecha_limite: String;
    private estado: String;

    public Tarea() {}

    public completar(): void {
        System.out.println("Ejecutando completar(): void en Tarea...");
    }
}


// 2. Clases Hijas
public class BugReport extends Tarea {
    private severidad: String;
    private pasos_para_reproducir: String;
    @Override
    public completar(): void {
        System.out.println("Comportamiento especializado en BugReport");
    }
}

public class NuevaCaracteristica extends Tarea {
    private criterios_aceptacion: String;
    private puntos_historia: int;
    @Override
    public completar(): void {
        System.out.println("Comportamiento especializado en NuevaCaracteristica");
    }
}

public class TareaMantenimiento extends Tarea {
    private sistema_afectado: String;
    private ventana_horaria: String;
    @Override
    public completar(): void {
        System.out.println("Comportamiento especializado en TareaMantenimiento");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        Tarea[] lista = {
            new BugReport(),
            new NuevaCaracteristica(),
            new TareaMantenimiento()
        };
        for (Tarea obj : lista) {
            obj.completar();
        }
    }
}

Factura, boleta y guía de despacho comparten folio y emisor, con campos tributarios distintos.

Qué hacer: Emite un documento de cada tipo y luego anula la factura (el método vive en la clase base).

// 1. Clase Padre / Base
public class DocumentoComercial {
    private numero_folio: int;
    private fecha_emision: String;
    private rut_emisor: String;

    public DocumentoComercial() {}

    public anular(): boolean {
        System.out.println("Ejecutando anular(): boolean en DocumentoComercial...");
    }
}


// 2. Clases Hijas
public class Factura extends DocumentoComercial {
    private monto_neto: double;
    private iva: double;
    private rut_receptor: String;
    @Override
    public anular(): boolean {
        System.out.println("Comportamiento especializado en Factura");
    }
}

public class Boleta extends DocumentoComercial {
    private monto_total_bruto: double;
    @Override
    public anular(): boolean {
        System.out.println("Comportamiento especializado en Boleta");
    }
}

public class GuiaDespacho extends DocumentoComercial {
    private direccion_entrega: String;
    private patente_transportista: String;
    @Override
    public anular(): boolean {
        System.out.println("Comportamiento especializado en GuiaDespacho");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        DocumentoComercial[] lista = {
            new Factura(),
            new Boleta(),
            new GuiaDespacho()
        };
        for (DocumentoComercial obj : lista) {
            obj.anular();
        }
    }
}

El laboratorio genera informes con el mismo flujo; cada examen tiene preparación y parámetros propios.

Qué hacer: Genera el informe de los tres exámenes. En sangre y resonancia considera los flags de ayuno/contraste en el texto del informe.

// 1. Clase Padre / Base
public class ExamenMedico {
    private codigo_fonasa: String;
    private paciente_rut: String;
    private fecha_toma: String;

    public ExamenMedico() {}

    public generar_informe(): String {
        System.out.println("Ejecutando generar_informe(): String en ExamenMedico...");
    }
}


// 2. Clases Hijas
public class ExamenSangre extends ExamenMedico {
    private requiere_ayuno_horas: int;
    private tubos_muestra: int;
    @Override
    public generar_informe(): String {
        System.out.println("Comportamiento especializado en ExamenSangre");
    }
}

public class Radiografia extends ExamenMedico {
    private zona_cuerpo: String;
    private dosis_radiacion: double;
    @Override
    public generar_informe(): String {
        System.out.println("Comportamiento especializado en Radiografia");
    }
}

public class ResonanciaMagnetica extends ExamenMedico {
    private duracion_minutos: int;
    private requiere_contraste: boolean;
    @Override
    public generar_informe(): String {
        System.out.println("Comportamiento especializado en ResonanciaMagnetica");
    }
}

// 3. Demostración de Polimorfismo en Main
public class Main {
    public static void main(String[] args) {
        ExamenMedico[] lista = {
            new ExamenSangre(),
            new Radiografia(),
            new ResonanciaMagnetica()
        };
        for (ExamenMedico obj : lista) {
            obj.generar_informe();
        }
    }
}