Desafíos de POO — Básico

Una lámpara con brillo regulable. Debe recordar si está encendida y en qué nivel está.

Qué hacer: Implementa la clase Lampara. Crea una lámpara, enciéndela, cambia el brillo a 2 y luego apágala. Valida que el nivel sea 1-3.

public class Lampara {
    private color: String;
    private esta_encendida: boolean;
    private nivel_brillo: int;

    public Lampara() {}

    public encender(): void {
        System.out.println("Ejecutando encender(): void en Lampara...");
    }

    public apagar(): void {
        System.out.println("Ejecutando apagar(): void en Lampara...");
    }

    public cambiar_brillo(nuevo_nivel: int): void {
        System.out.println("Ejecutando cambiar_brillo(nuevo_nivel: int): void en Lampara...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        Lampara obj = new Lampara();
        System.out.println("Objeto Lampara creado exitosamente.");
    }
}

Una taza con capacidad fija que se llena, se bebe y se vacía.

Qué hacer: Implementa Taza. Llena con "café", bebe 80 ml, intenta beber más de lo disponible y vacíala.

public class Taza {
    private capacidad_ml: double;
    private cantidad_actual_ml: double;
    private tipo_bebida: String;

    public Taza() {}

    public llenar(tipo: String): void {
        System.out.println("Ejecutando llenar(tipo: String): void en Taza...");
    }

    public beber(ml_a_tomar: double): void {
        System.out.println("Ejecutando beber(ml_a_tomar: double): void en Taza...");
    }

    public vaciar(): void {
        System.out.println("Ejecutando vaciar(): void en Taza...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        Taza obj = new Taza();
        System.out.println("Objeto Taza creado exitosamente.");
    }
}

Un semáforo de calle que solo admite Rojo, Amarillo o Verde y puede quedar fuera de servicio.

Qué hacer: Implementa Semaforo. Cambia a Verde, luego a Amarillo y simula una falla con apagar_por_falla().

public class Semaforo {
    private color_luz: String;
    private ubicacion_calle: String;
    private esta_operativo: boolean;

    public Semaforo() {}

    public cambiar_luz(nuevo_color: String): void {
        System.out.println("Ejecutando cambiar_luz(nuevo_color: String): void en Semaforo...");
    }

    public apagar_por_falla(): void {
        System.out.println("Ejecutando apagar_por_falla(): void en Semaforo...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        Semaforo obj = new Semaforo();
        System.out.println("Objeto Semaforo creado exitosamente.");
    }
}

Un termómetro que mide, convierte unidad y muestra la lectura.

Qué hacer: Implementa Termometro. Toma 36.6°C, muestra la lectura, cambia a Fahrenheit y vuelve a mostrar.

public class Termometro {
    private temperatura_actual: double;
    private unidad: String;

    public Termometro() {}

    public tomar_temperatura(valor: double): void {
        System.out.println("Ejecutando tomar_temperatura(valor: double): void en Termometro...");
    }

    public cambiar_unidad(): void {
        System.out.println("Ejecutando cambiar_unidad(): void en Termometro...");
    }

    public mostrar_lectura(): String {
        System.out.println("Ejecutando mostrar_lectura(): String en Termometro...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        Termometro obj = new Termometro();
        System.out.println("Objeto Termometro creado exitosamente.");
    }
}

Un despertador que guarda la hora actual, la alarma y si suena.

Qué hacer: Implementa RelojDespertador. Configura alarma a las 07:00, actívala y llama a sonar_alarma().

public class RelojDespertador {
    private hora_actual: String;
    private hora_alarma: String;
    private alarma_activada: boolean;

    public RelojDespertador() {}

    public configurar_alarma(hora: String): void {
        System.out.println("Ejecutando configurar_alarma(hora: String): void en RelojDespertador...");
    }

    public activar_alarma(): void {
        System.out.println("Ejecutando activar_alarma(): void en RelojDespertador...");
    }

    public sonar_alarma(): void {
        System.out.println("Ejecutando sonar_alarma(): void en RelojDespertador...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        RelojDespertador obj = new RelojDespertador();
        System.out.println("Objeto RelojDespertador creado exitosamente.");
    }
}

Una puerta que se abre/cierra y se bloquea con llave. No se puede abrir si está con llave.

Qué hacer: Implementa Puerta. Intenta abrir con llave puesta (debe fallar), quita la llave y abre.

public class Puerta {
    private material: String;
    private esta_abierta: boolean;
    private esta_con_llave: boolean;

    public Puerta() {}

    public abrir(): void {
        System.out.println("Ejecutando abrir(): void en Puerta...");
    }

    public cerrar(): void {
        System.out.println("Ejecutando cerrar(): void en Puerta...");
    }

    public poner_llave(): void {
        System.out.println("Ejecutando poner_llave(): void en Puerta...");
    }

    public quitar_llave(): void {
        System.out.println("Ejecutando quitar_llave(): void en Puerta...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        Puerta obj = new Puerta();
        System.out.println("Objeto Puerta creado exitosamente.");
    }
}

Marcador de dos jugadores con tiempo restante.

Qué hacer: Implementa MarcadorJuego. Suma 2 puntos a J1, 1 a J2, muestra el marcador y reinícialo.

public class MarcadorJuego {
    private puntos_jugador_1: int;
    private puntos_jugador_2: int;
    private tiempo_restante_segundos: int;

    public MarcadorJuego() {}

    public sumar_punto_j1(): void {
        System.out.println("Ejecutando sumar_punto_j1(): void en MarcadorJuego...");
    }

    public sumar_punto_j2(): void {
        System.out.println("Ejecutando sumar_punto_j2(): void en MarcadorJuego...");
    }

    public reiniciar_marcador(): void {
        System.out.println("Ejecutando reiniciar_marcador(): void en MarcadorJuego...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        MarcadorJuego obj = new MarcadorJuego();
        System.out.println("Objeto MarcadorJuego creado exitosamente.");
    }
}

Alcancía que guarda dinero hasta su capacidad y se rompe para retirarlo.

Qué hacer: Implementa Alcancia. Guarda $5000, intenta exceder la capacidad (debe rechazar) y rompe la alcancía.

public class Alcancia {
    private dueno: String;
    private total_ahorrado: double;
    private capacidad_maxima: double;

    public Alcancia() {}

    public guardar_dinero(monto: double): void {
        System.out.println("Ejecutando guardar_dinero(monto: double): void en Alcancia...");
    }

    public romper_alcancia(): void {
        System.out.println("Ejecutando romper_alcancia(): void en Alcancia...");
    }

    public ver_total(): double {
        System.out.println("Ejecutando ver_total(): double en Alcancia...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        Alcancia obj = new Alcancia();
        System.out.println("Objeto Alcancia creado exitosamente.");
    }
}

Billetera con saldo que se carga y se gasta. No permite gastar más de lo disponible.

Qué hacer: Implementa Billetera. Agrega $10000, gasta $3500, intenta gastar $10000 de nuevo (debe fallar) y consulta el saldo.

public class Billetera {
    private titular: String;
    private dinero_disponible: double;

    public Billetera() {}

    public agregar_dinero(monto: double): void {
        System.out.println("Ejecutando agregar_dinero(monto: double): void en Billetera...");
    }

    public gastar_dinero(monto: double): boolean {
        System.out.println("Ejecutando gastar_dinero(monto: double): boolean en Billetera...");
    }

    public consultar_plata(): double {
        System.out.println("Ejecutando consultar_plata(): double en Billetera...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        Billetera obj = new Billetera();
        System.out.println("Objeto Billetera creado exitosamente.");
    }
}

Ventilador con 4 velocidades (0 apagado .. 3 máxima) que puede girar oscilando.

Qué hacer: Implementa Ventilador. Sube a velocidad 2, activa el giro, baja a 1 y apaga.

public class Ventilador {
    private marca: String;
    private velocidad: int;
    private esta_girando: boolean;

    public Ventilador() {}

    public subir_velocidad(): void {
        System.out.println("Ejecutando subir_velocidad(): void en Ventilador...");
    }

    public bajar_velocidad(): void {
        System.out.println("Ejecutando bajar_velocidad(): void en Ventilador...");
    }

    public alternar_giro(): void {
        System.out.println("Ejecutando alternar_giro(): void en Ventilador...");
    }

    public apagar(): void {
        System.out.println("Ejecutando apagar(): void en Ventilador...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        Ventilador obj = new Ventilador();
        System.out.println("Objeto Ventilador creado exitosamente.");
    }
}

Un personaje jugable con estadísticas de vida, maná, nivel y estado vivo/muerto en una partida.

Qué hacer: Implementa PersonajeRPG. Recibe 40 de daño, usa poción para curar 25 HP, gasta maná para lanzar un hechizo y sube de nivel aumentando sus estadísticas.

public class PersonajeRPG {
    private nombre: String;
    private nivel: int;
    private puntos_vida: int;
    private puntos_mana: int;
    private esta_vivo: boolean;

    public PersonajeRPG() {}

    public recibir_danio(cantidad: int): void {
        System.out.println("Ejecutando recibir_danio(cantidad: int): void en PersonajeRPG...");
    }

    public curar(cantidad: int): void {
        System.out.println("Ejecutando curar(cantidad: int): void en PersonajeRPG...");
    }

    public gastar_mana(costo: int): boolean {
        System.out.println("Ejecutando gastar_mana(costo: int): boolean en PersonajeRPG...");
    }

    public subir_nivel(): void {
        System.out.println("Ejecutando subir_nivel(): void en PersonajeRPG...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        PersonajeRPG obj = new PersonajeRPG();
        System.out.println("Objeto PersonajeRPG creado exitosamente.");
    }
}

Un inventario de ítems con límite de slots de almacenamiento y peso máximo soportado.

Qué hacer: Implementa Inventario. Agrega ítems validando capacidad y peso, usa consumibles, suelta objetos y verifica si queda espacio libre.

public class Inventario {
    private capacidad_maxima: int;
    private items_actuales: int;
    private peso_maximo_kg: double;
    private peso_actual_kg: double;

    public Inventario() {}

    public agregar_item(peso_item: double): boolean {
        System.out.println("Ejecutando agregar_item(peso_item: double): boolean en Inventario...");
    }

    public usar_item(peso_item: double): void {
        System.out.println("Ejecutando usar_item(peso_item: double): void en Inventario...");
    }

    public soltar_item(peso_item: double): void {
        System.out.println("Ejecutando soltar_item(peso_item: double): void en Inventario...");
    }

    public tiene_espacio(): boolean {
        System.out.println("Ejecutando tiene_espacio(): boolean en Inventario...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        Inventario obj = new Inventario();
        System.out.println("Objeto Inventario creado exitosamente.");
    }
}

Una nave espacial en un juego shoot 'em up con escudo deflector, combustible y cañón láser.

Qué hacer: Implementa NaveEspacial. Dispara ráfagas láser, recibe impactos en el escudo, activa turbo propulsor y recarga energía.

public class NaveEspacial {
    private modelo: String;
    private escudo_energia: int;
    private combustible_litros: double;
    private municion_laser: int;

    public NaveEspacial() {}

    public disparar(): boolean {
        System.out.println("Ejecutando disparar(): boolean en NaveEspacial...");
    }

    public recibir_impacto(danio: int): void {
        System.out.println("Ejecutando recibir_impacto(danio: int): void en NaveEspacial...");
    }

    public activar_turbo(): void {
        System.out.println("Ejecutando activar_turbo(): void en NaveEspacial...");
    }

    public recargar_escudo(cantidad: int): void {
        System.out.println("Ejecutando recargar_escudo(cantidad: int): void en NaveEspacial...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        NaveEspacial obj = new NaveEspacial();
        System.out.println("Objeto NaveEspacial creado exitosamente.");
    }
}

Un poderoso jefe de calabozo con múltiples fases de combate, barra de vida y modo furia activado al bajar del 30% de salud.

Qué hacer: Implementa JefeMazmorra. Aplica daño al jefe, pasa a la fase 2 al vaciar la primera barra, activa furia para potenciar ataques y reinicia el encuentro si los jugadores caen.

public class JefeMazmorra {
    private nombre_jefe: String;
    private vida_maxima: int;
    private vida_actual: int;
    private fase_combate: int;
    private modo_furia: boolean;

    public JefeMazmorra() {}

    public recibir_danio(danio: int): void {
        System.out.println("Ejecutando recibir_danio(danio: int): void en JefeMazmorra...");
    }

    public cambiar_fase(): void {
        System.out.println("Ejecutando cambiar_fase(): void en JefeMazmorra...");
    }

    public activar_furia(): void {
        System.out.println("Ejecutando activar_furia(): void en JefeMazmorra...");
    }

    public reiniciar_jefe(): void {
        System.out.println("Ejecutando reiniciar_jefe(): void en JefeMazmorra...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        JefeMazmorra obj = new JefeMazmorra();
        System.out.println("Objeto JefeMazmorra creado exitosamente.");
    }
}

Una carta coleccionable estilo juego de cartas táctico con coste de energía, poder de ataque, puntos de defensa y rareza dorada.

Qué hacer: Implementa CartaTCG. Invoca la carta restando coste, ejecuta ataques contra cartas rivales, aplica bonificadores de daño y recibe ataques enemigos.

public class CartaTCG {
    private nombre_carta: String;
    private costo_energia: int;
    private puntos_ataque: int;
    private puntos_defensa: int;
    private es_dorada: boolean;

    public CartaTCG() {}

    public invocar(): boolean {
        System.out.println("Ejecutando invocar(): boolean en CartaTCG...");
    }

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

    public potenciar_ataque(bonus: int): void {
        System.out.println("Ejecutando potenciar_ataque(bonus: int): void en CartaTCG...");
    }

    public recibir_ataque(danio: int): void {
        System.out.println("Ejecutando recibir_ataque(danio: int): void en CartaTCG...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        CartaTCG obj = new CartaTCG();
        System.out.println("Objeto CartaTCG creado exitosamente.");
    }
}

Un periférico/gamepad inalámbrico con indicador de batería, conexión Bluetooth, motores de vibración háptica y asignación de jugador.

Qué hacer: Implementa MandoConsola. Conéctalo a la consola, dispara pulsos de vibración en colisiones, gestiona la batería y apágalo al desconectar.

public class MandoConsola {
    private id_jugador: int;
    private bateria_porcentaje: int;
    private esta_conectado: boolean;
    private vibracion_activa: boolean;

    public MandoConsola() {}

    public conectar(): void {
        System.out.println("Ejecutando conectar(): void en MandoConsola...");
    }

    public desconectar(): void {
        System.out.println("Ejecutando desconectar(): void en MandoConsola...");
    }

    public activar_vibracion(duracion_ms: int): void {
        System.out.println("Ejecutando activar_vibracion(duracion_ms: int): void en MandoConsola...");
    }

    public recargar_bateria(porcentaje: int): void {
        System.out.println("Ejecutando recargar_bateria(porcentaje: int): void en MandoConsola...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        MandoConsola obj = new MandoConsola();
        System.out.println("Objeto MandoConsola creado exitosamente.");
    }
}

Un cofre de tesoro con recompensas de oro según su rareza, bloqueo por llave y posibilidad de ser un monstruo Mímico.

Qué hacer: Implementa CofreLoot. Intenta forzar apertura, desbloquea con la llave correcta, recoge las monedas de oro y activa la trampa si resulta ser mímico.

public class CofreLoot {
    private tipo_rareza: String;
    private monedas_oro: int;
    private esta_bloqueado: boolean;
    private es_mimico: boolean;

    public CofreLoot() {}

    public desbloquear(tipo_llave: String): boolean {
        System.out.println("Ejecutando desbloquear(tipo_llave: String): boolean en CofreLoot...");
    }

    public abrir_cofre(): void {
        System.out.println("Ejecutando abrir_cofre(): void en CofreLoot...");
    }

    public reclamar_oro(): int {
        System.out.println("Ejecutando reclamar_oro(): int en CofreLoot...");
    }

    public activar_trampa(): void {
        System.out.println("Ejecutando activar_trampa(): void en CofreLoot...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        CofreLoot obj = new CofreLoot();
        System.out.println("Objeto CofreLoot creado exitosamente.");
    }
}

Un auto deportivo de carreras con telemetría de velocidad, marchas secuenciales, tanque de óxido nitroso (NOS) y desgaste de neumáticos.

Qué hacer: Implementa AutoCarreras. Acelera en recta, sube marchas secuenciales, activa el turbo de nitro para rebasar y frena dosificando los neumáticos.

public class AutoCarreras {
    private escuderia: String;
    private velocidad_kmh: double;
    private marcha_actual: int;
    private nitro_disponible: int;
    private desgaste_neumaticos: double;

    public AutoCarreras() {}

    public acelerar(incremento: double): void {
        System.out.println("Ejecutando acelerar(incremento: double): void en AutoCarreras...");
    }

    public frenar(decremento: double): void {
        System.out.println("Ejecutando frenar(decremento: double): void en AutoCarreras...");
    }

    public cambiar_marcha(nueva_marcha: int): void {
        System.out.println("Ejecutando cambiar_marcha(nueva_marcha: int): void en AutoCarreras...");
    }

    public activar_nitro(): void {
        System.out.println("Ejecutando activar_nitro(): void en AutoCarreras...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        AutoCarreras obj = new AutoCarreras();
        System.out.println("Objeto AutoCarreras creado exitosamente.");
    }
}

Una estructura defensiva con radio de alcance, daño base, tipo elemental (Fuego, Hielo, Rayo) y árbol de mejoras.

Qué hacer: Implementa TorreDefensa. Ataca oleadas enemigas dentro de su rango, mejora al siguiente nivel para ganar poder, cambia de elemento y gestiona su venta.

public class TorreDefensa {
    private tipo_elemento: String;
    private rango_ataque_metros: double;
    private danio_base: int;
    private nivel_mejora: int;
    private costo_mejora: int;

    public TorreDefensa() {}

    public atacar_objetivo(distancia: double): boolean {
        System.out.println("Ejecutando atacar_objetivo(distancia: double): boolean en TorreDefensa...");
    }

    public mejorar_torre(): void {
        System.out.println("Ejecutando mejorar_torre(): void en TorreDefensa...");
    }

    public cambiar_elemento(nuevo_elemento: String): void {
        System.out.println("Ejecutando cambiar_elemento(nuevo_elemento: String): void en TorreDefensa...");
    }

    public vender_torre(): int {
        System.out.println("Ejecutando vender_torre(): int en TorreDefensa...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        TorreDefensa obj = new TorreDefensa();
        System.out.println("Objeto TorreDefensa creado exitosamente.");
    }
}

Sistema de progresión de temporada con niveles (1-100), acumulación de puntos de experiencia (XP), pase Free vs Premium y desbloqueo de skins.

Qué hacer: Implementa PaseBatalla. Gana XP en partidas, sube niveles de pase, adquiere la versión Premium y reclama recompensas cosméticas exclusivas.

public class PaseBatalla {
    private temporada_numero: int;
    private nivel_actual: int;
    private exp_acumulada: int;
    private exp_para_siguiente_nivel: int;
    private es_premium: boolean;

    public PaseBatalla() {}

    public ganar_experiencia(puntos_exp: int): void {
        System.out.println("Ejecutando ganar_experiencia(puntos_exp: int): void en PaseBatalla...");
    }

    public subir_nivel_pase(): void {
        System.out.println("Ejecutando subir_nivel_pase(): void en PaseBatalla...");
    }

    public comprar_premium(): void {
        System.out.println("Ejecutando comprar_premium(): void en PaseBatalla...");
    }

    public reclamar_recompensa(): String {
        System.out.println("Ejecutando reclamar_recompensa(): String en PaseBatalla...");
    }
}

// Ejemplo de prueba
public class Main {
    public static void main(String[] args) {
        PaseBatalla obj = new PaseBatalla();
        System.out.println("Objeto PaseBatalla creado exitosamente.");
    }
}