Control de flujo de Java: la declaraci贸n del cambio

    Introducci贸n

    Las declaraciones condicionales y los bucles son una herramienta muy importante en la programaci贸n. No hay muchas cosas que podamos hacer con c贸digo que solo se pueda ejecutar l铆nea por l铆nea.

    Eso es lo que significa “control de flujo”: guiar la ejecuci贸n de nuestro programa, en lugar de dejar que se ejecute l铆nea por l铆nea independientemente de cualquier factor interno o externo. Cada lenguaje de programaci贸n admite alguna forma de control de flujo, si no expl铆citamente a trav茅s de ifsy fors o declaraciones similares, entonces impl铆citamente nos da las herramientas para crear tales construcciones, es decir, los lenguajes de programaci贸n de bajo nivel generalmente logran ese efecto con una gran cantidad de go-to comandos.

    Los bucles eran un concepto que se usaba mucho antes de que la programaci贸n de computadoras existiera, pero la primera persona en usar un bucle de software fue Ada Lovelace, com煤nmente conocida por su apellido de soltera, Byron, mientras calculaba N煤meros de Bernoulli, all谩 por el siglo XIX.

    En Java, hay varias formas de controlar el flujo del c贸digo:

    • declaraciones if y if-else
    • switch declaraciones
    • while y do-while declaraciones
    • for y enhanced for declaraciones
    • break y continue declaraciones

    La declaraci贸n de cambio

    Si deseamos comparar un valor con varios valores y ejecutar c贸digo en funci贸n de su igualdad, podr铆amos hacer algo como:

    String input = "someCommand";
    
    if (input.equals("date")) {
        System.out.println("The current date is: " + new Date());
    } else if (input.equals("help")) {
        System.out.println("The possible commands are...");
    } else if (input.equals("list")) {
        System.out.println("The files in this directory are...");
    } else if (input.equals("exit")) {
        System.out.println("Exiting application...");
    } else {
        System.out.println("Command Not Supported");
    }
    

    Esto puede volverse engorroso e ilegible r谩pidamente. los switch La declaraci贸n nos fue presentada precisamente para evitar esto siempre que sea posible. Esta declaraci贸n se usa cuando tenemos varias cosas diferentes que queremos que se ejecuten en funci贸n del valor de una sola expresi贸n:

    switch(variable) { 
        case constant1:
            // Do something if the variable is equal to constant1. 
            // constant1 must be of same type as variable
            // or easily converted to, such as Integer -> int
            break; 
        case constant2:
            // Some code
            break; 
        ... 
        default: 
            // Some code
            break;
    }
    

    La variable pasada como switch argumento es la variable o expresi贸n cuyo valor estamos comparando. Ese valor se compara con cada uno de los case valores. Si la variable que estamos comprobando coincide con alguno de los casos, se ejecuta el c贸digo que sigue a ese caso. Podemos tener tantos case declaraciones como queramos.

    Aqu铆 se presentan cuatro palabras clave nuevas: switch, case, breaky default.

    cambiar

    los switch declaraci贸n generalmente acepta una variable, aunque tambi茅n puede aceptar una expresi贸n si devuelve un tipo aceptado:

    // Comparing the value 5 with case values
    switch(5) {
        // Cases
    }
    
    int x = 5;
    int y = 10;
    
    // Comparing the value 15 with case values
    switch(x+y) {
        // Cases
    }
    
    // Booleans are not supported by switch statements, 
    // so this won't compile
    switch(!true) {
        // Cases
    }
    

    Si pasamos un null valor para el switch, un NullPointerException surgir谩.

    caso

    los case el valor de la etiqueta debe ser un constante de tiempo de compilaci贸n. Esto significa que para todos case valores, debemos utilizar literales / constantes (es decir, “abc”, 5, etc.) o variables que se han declarado final y se le asigna un valor:

    final int i = 5;
    int y = 15;
    final int z;
    z = 25;
    
    int x = 10;
    switch(x) {
        case i:
            // i can't be changed at any point due to the
            // `final` modifier, will compile
            break;
        case y:
            // Won't compile as `y` isn't a compile-time constant
            break;
        case 10+10:
            // Compiles, as 10+10 is a compile-time constant
            break;
        case z:
            // Doesn't compile as z wasn't initialized with
            // its declaration, thus it isn't considered to
            // be a compile-time constant
            break;
        case null:
            // Doesn't compile, there can't be a null case
            break;
    }
    

    Todos los casos deben ser 煤nicos, de lo contrario, el c贸digo Java no se compilar谩. Si los casos no fueran 煤nicos, no habr铆a forma de saber qu茅 caso ejecutar entre los valores duplicados.

    romper

    los break La palabra clave se utiliza para interrumpir el flujo del c贸digo dentro de los casos. Una vez el switch ha encontrado un caso que coincide con la variable pasada, procede a ejecutar el c贸digo del caso hasta que el primer break se encuentra la palabra clave o el final del switch bloquearse.

    Por ejemplo:

    int ourNumber = 1;
    
    switch(ourNumber) {
        case 1:
            System.out.println("One");
        case 2:
            System.out.println("Two");
        case 3:
            System.out.println("Three");
            break;
        case 4:
            System.out.println("Four");
    }
    

    El resultado de este c贸digo es:

    One
    Two
    Three
    

    En este ejemplo, el flujo de ejecuci贸n “no llega” a partir de la primera declaraci贸n de caso (que coincide con el ourNumber valor) al break declaraci贸n.

    Esto a veces puede llevar a que se ejecuten casos no deseados, por lo que debemos tener cuidado de agregar break declaraciones, y una buena idea es agregarlas por defecto en cada casey eliminarlos m谩s tarde si queremos ejecutar varios casos para algunas entradas. M谩s informaci贸n sobre break La declaraci贸n se puede encontrar aqu铆.

    Si quisi茅ramos que se ejecutara el mismo c贸digo para varios casos, este es un patr贸n com煤n utilizado:

    ...
    case "a":
    case "b":
        System.out.println("Variable is equal to constant1 or constant2!");
        break;
    ...
    

    Esto ejecutar铆a el System.out.println l铆nea si nuestra variable es igual a "a" o si es igual a "b".

    defecto

    los default caso es un fragmento de c贸digo que switch se ejecuta si la variable que le hemos pasado no coincide con ninguno de los casos dados. Esta declaraci贸n es opcional, aunque muy recomendable para evitar situaciones en las que la entrada definida por el usuario interrumpe todo el flujo de la aplicaci贸n.

    Tipos de datos aceptados

    los variable pasado como un switch El argumento puede ser uno de los siguientes:

    • carbonizarse
    • byte
    • corto
    • En t
    • Entero
    • Corto
    • Byte
    • Personaje
    • enumeraci贸n
    • String

    Este es un gran salto desde el if y else-if declaraciones, que solo apoyan boolean Expresiones

    Dicho esto, podemos reescribir f谩cilmente el if/if-else ejemplo del comienzo de este art铆culo:

     switch("someCommand") {
         case "date":
             System.out.println("The current date is: " + new Date());
             break;
         case "help":
             System.out.println("The possible commands are...");
             break;
         case "list":
             System.out.println("The files in this directory are...");
             break;
         case "exit":
             System.out.println("Exiting application...");
             break;
         default:
             System.out.println("Command Not Supported");
             break;
     }
    

    O, como otro ejemplo, podr铆amos pasar un n煤mero entero y reemplazar esta cadena de if y else-if bloques con una contraparte m谩s legible:

    int ourNumber = 4;
    
    if (ourNumber == 1) {
        System.out.println("One");
    }
    else if (ourNumber == 2) {
        System.out.println("Two");
    }
    else if (ourNumber == 3) {
        System.out.println("Three");
    }
    else if (ourNumber == 4) {
        System.out.println("Four");
    }
    else {
        System.out.println("Larger than 4");
    }
    

    El equivalente switch declaraci贸n tendr铆a el siguiente aspecto:

    switch(ourNumber) {
        case 1:
            System.out.println("One");
            break;
        case 2:
            System.out.println("Two");
            break;
        case 3:
            System.out.println("Three");
            break;
        case 4:
            System.out.println("Four");
            break;
        default:
            System.out.println("Larger than 4");
            break;
    }
    

    Est谩 claro que si ourNumber es igual a 1, el c贸digo despu茅s case 1: se ejecutar谩 y se imprimir谩 “Uno” en la salida est谩ndar.

    Nota: A diferencia de otros tipos de datos, las cadenas no se comparan con == operador, pero con el .equals() m茅todo al comparar todos los casos. Esto se hace para comparar el valor real de las cadenas y no la ubicaci贸n de la memoria.

    Declaraciones de conmutador anidadas

    Podemos anidar m煤ltiples switch declaraciones.

    switch(var1) {
        case constant1:
            switch(var2) {
                // ...
            }
            break;
        case constant2:
        ...
    }
    

    Expresiones lambda

    Java 12 tiene una forma nueva y m谩s concisa de manejar switch declaraciones que utilizan expresiones Lambda.

    Mediante el uso switch declaraciones de esta manera, las rupturas ya no son necesarias y devolver un valor es m谩s legible. Esto solo est谩 disponible como una opci贸n de vista previa actualmente. Un nuevo tipo de conmutador t铆pico se ver铆a as铆:

    switch(ourNumber) {
        case 7, 3, 8, 4 -> System.out.println("Very popular lucky number");
        case 5, 13, 9, 6 -> System.out.println("Kind of popular lucky number");
        default -> System.out.println("Not all that popular");
    }
    
    // Or something like:
    String s = switch(ourNumber) {
        case 7, 3, 8, 4 -> "Very popular lucky number";
        // ...
    }
    System.out.println(s);
    

    Conclusi贸n

    El control de flujo en el c贸digo es esencial para absolutamente todas las aplicaciones. Las declaraciones que alteran el flujo del c贸digo son bloques de construcci贸n fundamentales y cada desarrollador aspirante debe tener el control total / ser consciente de c贸mo funcionan.

     

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *