Declaración de ruptura en Java

Hola a todos los compañeros y simplemente a los interesados. Hoy veremos una característica del lenguaje de programación Java como el operador de interrupción. Este es el primer artículo sobre el tema de los operadores de transición, así que si te gusta, estaré encantado de escribir más. Me gustaría señalar de inmediato que este artículo está destinado principalmente a desarrolladores principiantes y que es posible que los estudiantes más avanzados no encuentren nada nuevo aquí para ellos. Entonces vamos. En Java, hay dos formas de cambiar el orden en que se ejecutan las instrucciones del programa: declaraciones de salto y mecanismo de manejo de excepciones. Hay tres operadores de salto en Java: romper, continuar y regresar. Hoy te invito a que mires más de cerca al operador break. El manejo de excepciones es un tema tan amplio que está más allá del alcance de este artículo. Hay tres formas de utilizar la declaración break en Java. La primera y más popular forma es utilizarla breakpara salir del bucle antes de tiempo, por ejemplo:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for (int i = 0; i < 10; i++) {
            if (i == number) {
                break;
            }
            System.out.println(i);
        }
        System.out.println("cycle was finished");
    }
}

Este ejemplo mostrará:

1
2
cycle was finished

Esto significa que cuando el contador del bucle illega a ser igual al parámetro pasado number, es decir, el número 3, la ejecución del bucle finaliza antes de tiempo. Si el programa tiene varios bucles anidados, interrumpa las salidas sólo del bucle más interno, por ejemplo:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for(int i = 0; i < 5; i++) {
            for (int j =0; j < 10; j++) {
                if(j == number) {
                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }
        System.out.println("cycles was finished");
    }
}

Este ejemplo produce el resultado:

012
012
012
012
012
cycles was finished

Como se puede ver en el ejemplo, el bucle interno se interrumpe cada vez en el número 3 (parámetro number) y el bucle externo se ejecuta 5 veces, como se esperaba. En Java, puede utilizar más de una instrucción break dentro de un bucle, pero esto no se recomienda, ya que la legibilidad y la estructura del código se degradan considerablemente. El segundo uso breakes usarlo para interrumpir la ejecución de declaraciones en ramas switch, por ejemplo:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }

    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
                break;
            case 2:
                System.out.println(number*number);
                break;
            case 3:
                System.out.println(number*number);
                break;
        }
        System.out.println("after switch");
    }
}

La ejecución de este ejemplo producirá el resultado:

4
after switch

La declaración break pasó el control al código que sigue al bloque completo switch. Si no lo especifica breaken switcheste ejemplo:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }
    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
            case 2:
                System.out.println(number*number);
            case 3:
                System.out.println(number*number);
        }
        System.out.println("after switch");
    }
}

El resultado no será el esperado:

4
4
after switch

Esto sucedió porque después de ejecutar el bloque, case 2el programa continuó ejecutando todos los bloques de casos posteriores , lo que nos dio el resultado correspondiente. En ocasiones esta característica del operador switch puede resultarnos beneficiosa, por ejemplo:

public class SimpleExample {
    public static void main(String[] args) {
        compare(2);
        compare(7);
        compare(12);
    }
    public static void compare(int number){
        switch (number){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("number is less than 5 or equal 5");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
                System.out.println("number is greater than 5");
                break;
            default:
                System.out.println("number is less than 0 or greater than 9");
        }
        System.out.println("after switch");
    }
}

Este programa compara un número dado con el número 5 y proporciona el siguiente resultado:

after switch
number is greater than 5
after switch
number is less than 0 or greater than 9
after switch

Cuando se llama a un método por primera vez, el operador switchtransfiere el control al operador case 2y luego al operador breaken case 5. La segunda llamada es similar a la primera, pero comienza con c case 7. La tercera llamada no encuentra un valor adecuado entre todos los casos, por lo que se ejecuta el operador default. La tercera forma es utilizar el operador breaken lugar del gotooperador C. Para hacer esto, usaremos una forma especial del operador breakllamado breakcon una etiqueta. Este formulario parece break метка;una etiqueta; suele ser cualquier nombre adecuado del espacio de nombres de Java, que precede a un bloque de código. Además, después de aplicar este bloque de código breakcon una etiqueta, el código continuará ejecutándose desde el lugar posterior al bloque con la etiqueta correspondiente, por ejemplo:

public class SimpleExample {
    public static void main(String[] args) {
        howWeUseLabels(true);
        System.out.println();
        howWeUseLabels(false);
    }
    public static void howWeUseLabels(boolean bool) {
        firstBlock:{
            secondBlock:{
                thirdBlock:{
                    System.out.println("We will see it always");
                    if(bool) {
                        break secondBlock;
                    }
                    System.out.println("We won't see it if bool == true");
                }
                System.out.println("We won't see it if bool == true");
            }
            System.out.println("We will see it always");
        }
    }
}

Este ejemplo producirá el siguiente resultado:

We will see it always
We will see it always

We will see it always
We won't see it if bool == true
We won't see it if bool == true
We will see it always

Después de la primera llamada al método, el operador breaktransfiere el control al final del bloque secondBlock, saliendo secondBlocky thirdBlock, mientras ejecuta otro operador println()al final firstBlock. Después de la segunda llamada, todas las líneas se muestran en la pantalla. Las etiquetas también se pueden utilizar para indicar ciclos. Cabe recordar que sólo se puede ir a una etiqueta desde dentro del bloque de código indicado por la etiqueta; por ejemplo, dicho código no se compilará:

public class SimpleExample {
    public static void main(String[] args) {
        label:{
            System.out.println("inside label");
        }
        if(true) {
            break label;
        }
        System.out.println("This is error");
    }
}

Notas sobre la limpieza del código y las declaraciones break: generalmente se acepta el consejo de utilizar la declaración breakcon mucho cuidado, ya que su uso breakhace que el bucle sea más difícil de entender y obliga al programador a mirar dentro del bucle para comprender los matices de su funcionamiento. Existe una regla heurística que break puede utilizar con más confianza en bucles más cortos y con más precaución en bucles largos y profundamente anidados, ya que esto aumenta la probabilidad de errores y complica la lectura y comprensión de su código por parte de otros programadores. Como escribí anteriormente, el uso de una gran cantidad de breakarchivos .dispersos por todo el código indica que el programador no comprende completamente por qué escribió su código de la forma en que lo hizo. Podría valer la pena considerar refactorizar dicho bucle dividiéndolo en varios bucles más pequeños. Trate de tener cuidado al utilizar break una etiqueta como reemplazo de goto, ya que esto complica la estructura del código. Eso es todo lo que quería contarles hoy sobre el operador breaken java. Estaré encantado de recibir críticas constructivas y también estoy dispuesto a escribir una continuación sobre operadores continuey return, si está interesado.