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

C

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.

 

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con tus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad