Variables en Java ejercicios — IMC, segundos y el inventario de la copistería (y el porcentaje que se quedaba en 100)

En la práctica de variables en Java provocamos las tres trampas del tema a propósito: la división entera, el desbordamiento y el == con textos. Ahora te toca a ti, con un giro: aquí no van a ser las protagonistas. Aparecen como herramientas (o como obstáculos) dentro de problemas normales, que es como aparecen en los exámenes.

Lo que me pasó con el ejercicio 2 la primera vez que lo hice: el desglose en días, horas y minutos me salió perfecto y el porcentaje del día se quedaba clavado en 100,00 %, pusiera los segundos que pusiera por encima de un día. Lo tienes en el «¿Qué falla aquí?».

Cómo usar este artículo

Hay tres ejercicios de nivel creciente. Cada uno tiene su enunciado, la salida que debe dar tu programa (es la salida real de la solución) y una caja con pistas. Intenta cada uno al menos diez minutos antes de abrir la pista, y la pista antes que la solución. Después, el «¿Qué falla aquí?» con tres errores muy frecuentes, las soluciones comentadas, un cuestionario tipo examen y el chuletario del tema.

Como en la práctica, los datos van escritos en el programa: todavía no usamos Scanner, if ni bucles (llegan en el control de flujo y en los bucles). Eso obliga a resolverlo todo con variables, operadores y tipos, que es justo lo que hay que dominar ahora.

Nivel básico

Ejercicio 1: calculadora de IMC

Escribe un programa que, para un peso de 70 kg y una altura de 1,75 m, calcule el Índice de Masa Corporal, el rango de peso saludable para esa altura y a qué categoría pertenece. Como aún no tenemos if, cada categoría se muestra como un boolean (true en la que toca).

• IMC = peso / (altura × altura).
• Rango saludable: IMC entre 18,5 y 24,9. El peso mínimo es 18,5 × altura² y el máximo, 24,9 × altura².
• Categorías: bajo peso (< 18,5), normopeso (de 18,5 a menos de 25), sobrepeso (de 25 a menos de 30) y obesidad (30 o más).

Salida esperada:

=== CALCULADORA DE IMC ===
Peso (kg):  70.0
Altura (m): 1.75
IMC:             22,86
Peso saludable:  entre 56,7 kg y 76,3 kg
Bajo peso:  false
Normopeso:  true
Sobrepeso:  false
Obesidad:   false

Nivel intermedio

Ejercicio 2: conversor de tiempo

Escribe un programa que descomponga 90061 segundos en días, horas, minutos y segundos, lo muestre también en formato de reloj (1 d 01:01:01), calcule qué porcentaje de un día completo representan y, para comprobar, vuelva a calcular el total a partir de las cuatro piezas.

Salida esperada:

=== CONVERSOR DE TIEMPO ===
Segundos totales: 90061
1 d, 1 h, 1 min y 1 s
Formato reloj: 1 d 01:01:01
Porcentaje de un día: 104,24 %
Comprobación: 90061 segundos

Desafío final

Ejercicio 3: el inventario de la copistería

La copistería de la facultad tiene tres productos (precios inventados):

Escribe un programa que muestre una tabla con el precio base, el precio con IGIC (el impuesto de Canarias, un 7 % en el tipo general) y las unidades; el total de unidades; el valor del inventario (precio × unidades de cada producto, sumado) calculado de dos formas, con double y con céntimos en un long; el producto más caro y el más barato, y el precio medio por unidad. Sin arrays ni if: tres juegos de variables.

Salida esperada:

INVENTARIO DE LA COPISTERÍA
Producto        Base     +IGIC  Stock
Portátil      899,99    962,99      5
Ratón          29,99     32,09     23
Teclado        79,99     85,59     12
Unidades: 40
Valor con double (println): 6149.599999999999
Valor con double (printf):  6149,60 €
Valor en céntimos: 614960 → 6149,60 €
Más caro: 899.99 € | más barato: 29.99 €
Precio medio por unidad: 153,74 €

¿Qué falla aquí?

Tres fragmentos con errores muy frecuentes. Antes de leer la explicación, decide qué imprime cada uno (o si compila).

Fragmento 1: el porcentaje que se queda en 100

public class Porcentaje {
    public static void main(String[] args) {
        int segundos = 90061;
        double porcentaje = segundos / 86400 * 100;
        System.out.printf("%.2f %%%n", porcentaje);
    }
}

Lo que imprime:

100,00 %

segundos / 86400 son dos int: 90061 / 86400 = 1. Después, 1 × 100 = 100, que se guarda en el double como 100.0. Que la variable sea double no ayuda, porque la división ya se ha hecho entera. El arreglo es convertir antes de dividir: (double) segundos / 86400 * 100, que da 104,24. Este era mi 100,00 % del principio.

Fragmento 2: el valor del stock

public class ValorStock {
    public static void main(String[] args) {
        double precio = 29.99;
        int stock = 23;
        int valor = precio * stock;
        System.out.println(valor);
    }
}

Lo que dice javac:

ValorStock.java:5: error: incompatible types: possible lossy conversion from double to int
        int valor = precio * stock;
                           ^
1 error

precio * stock es double × int, y el resultado es double (689,77). Guardarlo en un int perdería los céntimos, y Java no lo hace sin permiso. Hay dos arreglos, según lo que quieras: double valor = precio * stock; si quieres el importe, o trabajar en céntimos (long cent = Math.round(precio * 100) * stock;) si quieres un entero exacto. El cast (int) (precio * stock) compilaría, pero tiraría los 77 céntimos.

Fragmento 3: el usuario que no coincide

public class Usuario {
    public static void main(String[] args) {
        String nombre = "laura";
        String usuario = nombre.substring(0, 1) + "santana";
        System.out.println(usuario);
        System.out.println(usuario == "lsantana");
    }
}

Lo que imprime:

lsantana
false

La primera línea demuestra que el texto es lsantana. Y aun así, == da false: usuario se ha construido al ejecutar con substring y +, así que es un objeto nuevo, distinto del literal "lsantana". == compara las flechas, no las letras. Arreglo: usuario.equals("lsantana").

Soluciones comentadas

Solución del ejercicio 1

/** Ejercicio 1: IMC con datos fijos y la clasificación con booleanos (sin if, que llega en el tema siguiente). */
public class CalculadoraIMC {
    public static void main(String[] args) {
        final double IMC_MIN = 18.5;            // límites del rango saludable
        final double IMC_MAX = 24.9;
        double peso = 70;                       // el int 70 se convierte solo en 70.0
        double altura = 1.75;

        double imc = peso / (altura * altura);  // altura^2 en Java sería otra cosa (XOR)
        double pesoMin = IMC_MIN * altura * altura;
        double pesoMax = IMC_MAX * altura * altura;
        boolean bajoPeso = imc < IMC_MIN;
        boolean normopeso = imc >= IMC_MIN && imc < 25;
        boolean sobrepeso = imc >= 25 && imc < 30;
        boolean obesidad = imc >= 30;

        System.out.println("=== CALCULADORA DE IMC ===");
        System.out.println("Peso (kg):  " + peso);
        System.out.println("Altura (m): " + altura);
        System.out.printf("IMC:             %.2f%n", imc);
        System.out.printf("Peso saludable:  entre %.1f kg y %.1f kg%n", pesoMin, pesoMax);
        System.out.println("Bajo peso:  " + bajoPeso);
        System.out.println("Normopeso:  " + normopeso);
        System.out.println("Sobrepeso:  " + sobrepeso);
        System.out.println("Obesidad:   " + obesidad);
    }
}

Por qué está escrita así:

• double peso = 70;: el 70 es un int, pero cabe en un double y Java lo convierte solo (widening). Por eso la salida dice 70.0.
• Las constantes IMC_MIN e IMC_MAX evitan escribir 18.5 y 24.9 en varios sitios: si cambiara el criterio, se cambia una línea.
• imc >= IMC_MIN && imc < 25: para normopeso usamos < 25 y no <= 24.9. ¿Por qué? Porque un IMC de 24,95 no es ni normopeso (pasa de 24,9) ni sobrepeso (no llega a 25): se quedaría sin categoría. Con < 25 no hay huecos entre las categorías.

Cuentas a mano: 1,75 × 1,75 = 3,0625; 70 / 3,0625 = 22,857… → 22,86. Peso mínimo: 18,5 × 3,0625 = 56,66 → 56,7; máximo: 24,9 × 3,0625 = 76,26 → 76,3. (La versión anterior de este artículo decía 80,1 kg: estaba mal, no salía de su propia fórmula.)

Solución del ejercicio 2

/** Ejercicio 2: descomponer 90061 segundos con / y %, y el porcentaje de un día con el cast en su sitio. */
public class ConversorTiempo {
    public static void main(String[] args) {
        final int SEG_DIA = 24 * 60 * 60;       // 86400: que lo calcule Java
        final int SEG_HORA = 60 * 60;           // 3600
        int totalSegundos = 90061;

        int dias = totalSegundos / SEG_DIA;     // días completos
        int resto = totalSegundos % SEG_DIA;    // lo que sobra tras quitar los días
        int horas = resto / SEG_HORA;
        resto = resto % SEG_HORA;               // reutilizamos resto
        int minutos = resto / 60;
        int segundos = resto % 60;

        double porcentaje = (double) totalSegundos / SEG_DIA * 100;   // cast ANTES de dividir
        int vuelta = dias * SEG_DIA + horas * SEG_HORA + minutos * 60 + segundos;

        System.out.println("=== CONVERSOR DE TIEMPO ===");
        System.out.println("Segundos totales: " + totalSegundos);
        System.out.printf("%d d, %d h, %d min y %d s%n", dias, horas, minutos, segundos);
        System.out.printf("Formato reloj: %d d %02d:%02d:%02d%n", dias, horas, minutos, segundos);
        System.out.printf("Porcentaje de un día: %.2f %%%n", porcentaje);
        System.out.println("Comprobación: " + vuelta + " segundos");
    }
}

La traza del desglose, paso a paso:

Decisiones de diseño:

• SEG_DIA = 24 * 60 * 60 en lugar de escribir 86400: Java hace la cuenta (no te equivocas) y el nombre explica qué es. Aquí no hay riesgo de desbordamiento: 86400 cabe de sobra en un int.
• resto se reutiliza: primero guarda lo que sobra tras los días y luego lo que sobra tras las horas. Ahorra variables, pero no lo hagas si complica la lectura.
• El porcentaje: (double) 90061 / 86400 = 1,04237… × 100 = 104,24 %.
• La línea de comprobación recompone el total: 1 × 86400 + 1 × 3600 + 1 × 60 + 1 = 90061. Si alguna vez no cuadra, el fallo está en el desglose.

Solución del ejercicio 3

/**
 * Desafío: inventario de tres productos de la copistería de la facultad (precios inventados, IGIC del 7 %).
 * Sin arrays ni if: tres juegos de variables, Math.max/Math.min y las cuentas en céntimos.
 */
public class Tienda {
    public static void main(String[] args) {
        final double IGIC = 0.07;                    // impuesto de Canarias, tipo general

        String nombre1 = "Portátil";  double precio1 = 899.99;  int stock1 = 5;
        String nombre2 = "Ratón";     double precio2 = 29.99;   int stock2 = 23;
        String nombre3 = "Teclado";   double precio3 = 79.99;   int stock3 = 12;

        // Valor del inventario con double: precio * stock y suma
        double valorDouble = precio1 * stock1 + precio2 * stock2 + precio3 * stock3;

        // Lo mismo en céntimos (long): enteros exactos
        long cent1 = Math.round(precio1 * 100);      // 89999
        long cent2 = Math.round(precio2 * 100);      // 2999
        long cent3 = Math.round(precio3 * 100);      // 7999
        long valorCent = cent1 * stock1 + cent2 * stock2 + cent3 * stock3;

        double masCaro = Math.max(precio1, Math.max(precio2, precio3));
        double masBarato = Math.min(precio1, Math.min(precio2, precio3));
        int unidades = stock1 + stock2 + stock3;

        System.out.println("INVENTARIO DE LA COPISTERÍA");
        System.out.printf("%-10s %9s %9s %6s%n", "Producto", "Base", "+IGIC", "Stock");
        System.out.printf("%-10s %9.2f %9.2f %6d%n", nombre1, precio1, precio1 * (1 + IGIC), stock1);
        System.out.printf("%-10s %9.2f %9.2f %6d%n", nombre2, precio2, precio2 * (1 + IGIC), stock2);
        System.out.printf("%-10s %9.2f %9.2f %6d%n", nombre3, precio3, precio3 * (1 + IGIC), stock3);
        System.out.println("Unidades: " + unidades);
        System.out.println("Valor con double (println): " + valorDouble);
        System.out.printf("Valor con double (printf):  %.2f €%n", valorDouble);
        System.out.println("Valor en céntimos: " + valorCent + " → " + valorCent / 100 + "," + valorCent % 100 + " €");
        System.out.println("Más caro: " + masCaro + " € | más barato: " + masBarato + " €");
        System.out.printf("Precio medio por unidad: %.2f €%n", (double) valorCent / unidades / 100);
    }
}

Lo que hay que mirar de la salida:

• El println del double dice 6149.599999999999. Las cuentas son 899,99 × 5 = 4499,95; 29,99 × 23 = 689,77; 79,99 × 12 = 959,88; total, 6149,60. Pero 899,99 no se puede guardar exacto en binario (como 1/3 no se puede escribir exacto en decimal), y los pequeños errores se acumulan. printf con %.2f redondea y lo esconde (6149,60), pero el número guardado es el otro.
• En céntimos, el resultado es exacto: 89999 × 5 + 2999 × 23 + 7999 × 12 = 449995 + 68977 + 95988 = 614960. Para escribirlo en euros, valorCent / 100 da 6149 (división entera) y valorCent % 100 da 60.
• Math.max(precio1, Math.max(precio2, precio3)): el de dentro elige el mayor de 2 y 3; el de fuera, el mayor entre ese y el 1. Lo mismo con Math.min. Sin if, solo podemos saber el precio, no el nombre del producto; con if (tema siguiente) se puede guardar también el nombre.
• El precio medio por unidad: (double) valorCent / unidades / 100 = 614960 / 40 / 100 = 153,74 €. El cast va delante para que la primera división ya sea con decimales.
• Los precios con IGIC: 899,99 × 1,07 = 962,99; 29,99 × 1,07 = 32,09; 79,99 × 1,07 = 85,59 (redondeados por printf).

Cuestionario tipo examen

Ahora ponte a prueba como en el examen. El cuestionario de Java de FP2 es así: 15 preguntas en 15 minutos sobre todo el temario de Java, de respuesta única, múltiple (los fallos restan), verdadero o falso, huecos, relacionar, respuesta corta y «¿qué imprime este código?». Aquí tienes 11 preguntas originales sobre variables y tipos en Java. Contesta sin ejecutar nada, pulsa Comprobar y lee la explicación de cada una. Estas preguntas son también el banco del simulacro de teoría de FP2, que las mezclará con las de los demás temas de Java.

int a = 7, b = 2;
double c = a / b;
double d = (double) a / b;
System.out.println(c + " " + d);

System.out.print('A' + 1);
System.out.print(" ");
System.out.println("" + 'A' + 1);

int x = Integer.MAX_VALUE;
x = x + 1;
System.out.println(x == Integer.MIN_VALUE);

String s = "12";
int n = Integer.parseInt(s) + 3;
System.out.println(s + 3 + " " + n);

System.out.println((int) 9.99 + (int) -2.7);

Míralo paso a paso en Python Tutor

pythontutor.com ejecuta el código línea a línea y enseña el valor de cada variable. Elige Java y pega esta versión del ejercicio 2 con el fragmento 1 dentro:

public class TiempoTutor {
    public static void main(String[] args) {
        int total = 90061;
        int dias = total / 86400;
        int resto = total % 86400;
        int horas = resto / 3600;
        resto = resto % 3600;
        int minutos = resto / 60;
        int segundos = resto % 60;
        double mal = total / 86400 * 100;
        double bien = (double) total / 86400 * 100;
        System.out.println(dias + " " + horas + " " + minutos + " " + segundos);
        System.out.println(mal + " " + bien);
    }
}

Salida:

1 1 1 1
100.0 104.2372685185185

Qué observar:

1. Mira cómo resto cambia de valor: primero 3661 y, tras resto = resto % 3600;, 61. Es la tabla de traza de la solución.
2. En double mal = total / 86400 * 100; el valor aparece como 100.0: la división entera ya había dejado un 1.
3. En double bien = … aparece 104.2372685185185, con todos sus decimales. printf los redondearía a 104,24.
4. Fíjate en que dias, horas, minutos y segundos son int en todo momento: el desglose no necesita ni un decimal.

Chuletario: variables en Java

Lo esencial en 30 segundos: cada variable tiene un tipo fijo (int, double, char, boolean, String…). Java calcula con el tipo de los operandos, así que int / int trunca y un int que se pasa de 2.147.483.647 da la vuelta. Subir de tipo es automático; bajar exige cast y trunca. Los textos se comparan con equals().

Plantillas de los ejercicios:

// Desglose con / y %
int dias = total / 86400;   int resto = total % 86400;
int horas = resto / 3600;   resto = resto % 3600;
int minutos = resto / 60;   int segundos = resto % 60;

// Dinero en céntimos
long cent = Math.round(precio * 100);
long valor = cent * unidades;
System.out.printf("%d,%02d €%n", valor / 100, valor % 100);

// Clasificar sin if: un boolean por categoría
boolean normopeso = imc >= 18.5 && imc < 25;

Antes de entregar, pregúntate:

1. ¿Hay alguna división cuyos dos lados sean enteros? ¿Quiero decimales ahí?
2. ¿Alguna cuenta puede pasar de 2.000 millones?
3. ¿He usado (int) donde quería redondear?
4. ¿He comparado algún String con ==?

Si quieres seguir, el siguiente tema es el control de flujo en Java: con if y switch, el IMC podrá decir directamente «Normopeso» y la copistería, qué producto es el más caro.

¿Te ha servido este artículo? Así puedes apoyar SergioLearns →