Debug en IntelliJ IDEA

1. Bug

Los programadores tienen su propia jerga. Y la primera palabra que conocerás de cerca será bug (del inglés bug — bicho). Esta palabra denota un error en el programa, por el cual hace algo mal, se bloquea o da un resultado extraño.

Si un programa funciona de forma extraña, pero el programador asegura que así estaba pensado, se suele decir: "No es un bug, es una feature". Internet está lleno de memes sobre este tema.

Nota histórica

Cuenta la leyenda que en septiembre de 1947, los científicos de Harvard estaban probando la computadora Mark II. Fallaba. Al revisar todos los contactos, encontraron una polilla real atrapada entre los relés. Pegaron el insecto en el registro con la leyenda "First actual case of bug being found" (Primer caso real de un bicho encontrado).

Desde entonces, el proceso de encontrar y corregir errores se llama debug o depuración.

---

2. Debug Mode

Para encontrar un error, los programadores utilizan el Debugger. Es una herramienta especial dentro de IntelliJ IDEA que te permite pausar la ejecución del programa y echar un vistazo "bajo el capó".

IntelliJ IDEA puede ejecutar tu programa en dos modos:

En el modo de depuración puedes ejecutar el programa línea por línea, observando cómo cambian los valores de las variables.

3. Breakpoints (Puntos de interrupción)

Para que el Debugger entienda dónde debe detenerse, debes poner un Break Point. Sin él, el programa simplemente volará hasta el final, como de costumbre.

Vamos a practicar con un ejemplo real. Hemos movido la lógica de multiplicación a un método separado para mostrar todo el poder del depurador. Copia este código en IDEA:

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            int result = calculateMultiply(i);  // <--- Queremos detenernos aquí
            sum += result;
            System.out.println("Step: " + i + ", Result: " + result + ", Sum: " + sum);
        }
        System.out.println("Final Sum: " + sum);
    }

    public static int calculateMultiply(int number) {
        return number * 2;
    }
}

Tarea. Queremos ver cómo cambian las variables dentro del bucle y echar un vistazo dentro de nuestro método.

Acción. Haz clic con el ratón en la estrecha franja gris a la izquierda de la línea int result = calculateMultiply(i);. Aparecerá un círculo rojo.

Ahora ejecuta el programa a través de Debug (icono de bicho). El programa se iniciará e instantáneamente se "congelará" antes de ejecutar esta línea.

4. Controles: F8, F7, F9

Cuando el programa está en pausa, tienes un panel de control en la parte superior del panel del Debugger.

F8 — Step Over (Paso por encima)

Presiona F8. El programa ejecutará la línea actual (llamará al método, obtendrá el resultado) y pasará a la siguiente sum += result;.

Presiona F8 de nuevo. El programa sumará los números. Verás cómo cambian los valores de las variables.

Presiona F8 una vez más. Verás la salida en la consola.

Esta es la forma principal de moverse: línea por línea, sin entrar en los detalles internos de los métodos.

F9 — Resume Program (Reanudar programa)

Tenemos un bucle del 1 al 5. Presionar F8 cinco veces para dar una vuelta al bucle es largo. ¿Y si el bucle tiene 1000 iteraciones?

Presiona F9. El programa se "descongelará", ejecutará todo el resto del código en la iteración actual, pasará a la segunda vuelta y... se detendrá de nuevo en el Breakpoint.

De esta manera, usando F9 puedes desplazarte rápidamente por los bucles: una pulsación — una iteración.

F7 — Step Into (Paso adentro)

Si el código encuentra una llamada a tu método (en nuestro caso calculateMultiply(i)), y presionas F8, el Debugger simplemente lo ejecutará y seguirá adelante. Pero si quieres ver cómo funciona el código dentro de este método, presiona F7.

Intenta presionar F7 cuando el programa se detenga en la línea int result = calculateMultiply(i);. El Debugger te llevará dentro del método calculateMultiply, y verás cómo se pasa el valor al parámetro number.

Shift + F8 — Step Out (Paso afuera)

¿Qué hacer si presionaste F7 accidentalmente en la línea System.out.println(...) y entraste en las profundidades del código del sistema de Java? Leer miles de líneas de código ajeno es aburrido e incomprensible.

Presiona Shift + F8. El programa ejecutará rápidamente todo lo que queda en el método actual y te devolverá a donde viniste (a tu método main).

5. ¿Dónde ver los valores?

Volvamos a nuestro ejemplo con el bucle.

Método 1: Inline Debugging

Mira directamente en el editor de código. A la derecha de las líneas, IDEA escribe los valores actuales en gris.

Método 2: Panel Variables

En la parte inferior de la ventana del Debugger está la pestaña Variables. Allí se muestran todas las variables actuales.

Aclaración importante para Java: Los tipos primitivos (por ejemplo, int) muestran su valor de inmediato. Pero los objetos y arrays (por ejemplo, String[]) almacenan muchos datos en su interior. Para ver su contenido, debes hacer clic en la pequeña flecha a la izquierda de la variable para "desplegar" el objeto.

Método 3: Panel Frames

A la izquierda de las variables hay una lista llamada Frames (Pila de llamadas). Muestra en qué paso se encuentra actualmente el programa.

Por ejemplo, la inscripción main:6, Main significa:

• Estás en el método main de la clase Main.
• Te has detenido en la línea número 6.

Esta es tu dirección exacta en el código. Si entras en otro método (presionas F7 en calculateMultiply), aparecerá una nueva entrada calculateMultiply:13, Main en la parte superior de esta lista, indicando que se ha llamado a un nuevo método desde el anterior.

6. Evaluate Expression

A veces, mirar las variables no es suficiente. Quieres preguntar: "¿Y qué pasaría si...?"

Presiona Alt + F8 (Windows/Linux) o Option + F8 (macOS). Se abrirá la ventana "Evaluate". También puedes introducir expresiones directamente en la línea debajo del panel Variables»

Aquí puedes escribir cualquier código utilizando las variables actuales. Por ejemplo, en nuestro bucle escribe:

sum + 100

Presiona Enter e IDEA calculará el resultado sin cambiar el programa real. Este es tu borrador para experimentar.

7. Conditional Breakpoints

Imagina que tienes un bucle de 10 000 iteraciones y el error ocurre solo en el paso 5000. Presionar F9 cinco mil veces es una mala idea.

Haz clic con el botón derecho del ratón en el círculo rojo del Breakpoint. Aparecerá una ventana emergente. En el campo Condition escribe una condición en Java, por ejemplo: i == 5. Presiona Done.

Ahora, si ejecutas el Debugger, el programa ignorará las primeras 4999 vueltas y se detendrá solo cuando la condición sea true. ¡Esto te ahorrará horas de trabajo!

8. Gestionar todos los Breakpoints

A veces los principiantes ponen tantos Breakpoints en diferentes archivos del proyecto que el programa luego se detiene constantemente en lugares inesperados. Buscar los círculos rojos por todos los archivos manualmente lleva mucho tiempo.

Presiona Ctrl + Shift + F8 (Windows/Linux) o Cmd + Shift + F8 (macOS). Se abrirá la ventana Breakpoints.

Aquí ves una lista de todos los puntos de interrupción en tu proyecto. Puedes desmarcarlos (desactivarlos temporalmente) o eliminarlos con la tecla Delete.

9. Resumen

Hemos revisado el arsenal básico de un desarrollador Java para encontrar errores. El depurador (Debugger) es lo que transforma la escritura de código de "adivinar en los posos del café" en un trabajo de ingeniería preciso.

La capacidad de encontrar rápidamente la causa de un error es una habilidad que se valora en el desarrollo comercial incluso más que la capacidad de escribir código rápidamente. Practica con los Conditional Breakpoints y la Evaluación (Evaluation), y ningún bug se te escapará.