Sentencias de salto

Las sentencias de salto permiten interrumpir la ejecución de un bloque de código, o saltar a una parte específica del código.

Entre ellas podemos encontrar a la sentencia break, la sentencia continue, la sentencia return y la sentencia throw. En este tema analizaremos las sentencias break y continue, y dejaremos la sentencia return otro tema. En cuanto a la sentencia throw, dada su naturaleza, no la veremos en este curso.

Sentencia break

Al analizar otras estructuras de control hemos empleado una de estas sentencias, la sentencia break. La cual permite interrumpir la ejecución de un bloque de código, ya sea un bucle (de cualquier tipo) o una sentencia switch-case.

Su sintaxis es muy sencilla, emplea la palabra reservada del mismo nombre, seguida de un punto y coma ;.

Debemos tener cuidado al emplear la sentencia break, ya que interrumpe abruptamente la ejecución del bloque de código en el que se encuentra, y por lo tanto, impiendo que se ejecuten las sentencias que se encuentren debajo de ella.

Existen dos formas de emplear esta sentencia, etiquetada y no etiquetada. Hasta el momento, solo hemos empleado la forma no etiquetada, por lo que veremos un ejemplo de la forma etiquetada.

Imaginemos que tenemos un tiempo límite de 10 segundos y dos tareas que necesitamos realizar. Cada tarea toma un tiempo variable (en segundos) para completarse, y queremos saber si podemos completar ambas tareas en el tiempo dado.

public class EjemploBreakEtiquetas {
    public static void main(String[] args) {
        int tiempoLimite = 10;

        outerLoop: // Etiqueta para el bucle externo
        for (int tiempoTarea1 = 1; tiempoTarea1 <= tiempoLimite; tiempoTarea1++) {
            innerLoop: // Etiqueta para el bucle interno
            for (int tiempoTarea2 = 1; tiempoTarea2 <= tiempoLimite; tiempoTarea2++) {
                if (tiempoTarea1 + tiempoTarea2 > tiempoLimite) {
                    System.out.println("No podemos completar ambas tareas en el tiempo dado.");
                    break outerLoop; // Esto romperá el bucle externo, no sólo el interno
                }

                if (tiempoTarea1 + tiempoTarea2 == tiempoLimite) {
                    System.out.println("Podemos completar la primera tarea en " + tiempoTarea1 + " segundos, y la segunda tarea en " + tiempoTarea2 + " segundos.");
                    break outerLoop; // Esto también romperá el bucle externo, no sólo el interno
                }
            }
        }
    }
}

En el ejemplo anterior, empleamos dos bucles anidados, uno dentro del otro. El bucle externo se encarga de iterar sobre el tiempo de la primera tarea, y el bucle interno se encarga de iterar sobre el tiempo de la segunda tarea.

Cuando se encuentra una combinación de tiempos que cumple con la condición establecida, se interrumpe la ejecución de ambos bucles, empleando la sentencia break etiquetada outerLoop.

Esto es posible gracias a que, en Java, los bucles pueden etiquetarse, lo cual permite identificarlos de manera única. En este caso, el bucle externo se etiqueta como outerLoop, y el bucle interno se etiqueta como innerLoop.

Si no empleamos etiquetas en la sentencia break, la sentencia interrumpirá la ejecución del bucle más profundo en el que se encuentre. En este caso, el bucle interno se vería interrumpido, es decir, el bucle denominado innerLoop.

Un ejemplo simplificado de esto puede ser como sigue:

public class EjemploBreakSimplificado {
    public static void main(String[] args) {
        outerLoop:
        for (int i = 0; i < 3; i++) {
            System.out.println("Iteración externa: " + i);
            innerLoop:
            for (int j = 0; j < 3; j++) {
                System.out.println("Iteración interna: " + j);
                if (j == 1) {
                    System.out.println("Rompiendo el bucle interno");
                    break innerLoop; // Rompemos el bucle interno
                }
            }
            if (i == 1) {
                System.out.println("Rompiendo el bucle externo");
                break outerLoop; // Rompemos el bucle externo
            }
        }
    }
}

Este tendría la siguiente salida:

Iteración externa: 0
Iteración interna: 0
Iteración interna: 1
Rompiendo el bucle interno
Iteración externa: 1
Iteración interna: 0
Iteración interna: 1
Rompiendo el bucle interno
Rompiendo el bucle externo

Sentencia continue

La sentencia continue permite saltar una iteración de un bucle, es decir, permite omitir la ejecución actual del bloque de código, y continuar con la siguiente iteración.

Por ejemplo, el siguiente código muestra los números pares entre 0 y 10 (ambos incluidos), pero agregamos una condición adicional: si el número es 6, omitimos la ejecución actual del bloque de código, y continuamos con la siguiente iteración.

public class EjemploContinue {
    public static void main(String[] args) {
        for (int numero = 0; numero <= 10; numero += 2) {
            if (numero == 6) {
                continue;
            }

            System.out.println(numero);
        }
    }
}

Como podemos observar, el número 6 no se muestra en la consola, ya que omitimos su ejecución. Sin embargo, el bucle continúa ejecutándose, y muestra los números 0, 2, 4, 8 y 10.