Control de flujo de Java: declaraciones if y if-else

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 incondicionalmente.

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.

go-to Los comandos deben evitarse en la mayoría de las situaciones, siempre que usemos un lenguaje de programación que nos brinde las herramientas para evitarlo, como lo hacen Java y todos los lenguajes similares de forma remota (hay una pequeña excepción a esta regla al romper bucles anidados).

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

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

La declaración if

los if La declaración es probablemente la forma más común de control de flujo, independientemente del idioma. Es muy simple e intuitivo:

Te puede interesar:Control de flujo de Java: bucles para y para cada

if (true) {
    // Execute this code block if the argument/expression is true
}

Dado que en muchos casos, solo se debe ejecutar una sola línea de código, puede omitir el uso de las llaves y simplemente sangrar la siguiente línea, aunque esto solo funciona para una sola línea:

if (true)
    System.out.println("Inside the if block");
    System.out.println("I have nothing to do with the if block!");
System.out.println("Neither do I!");

Por lo general, no ingresamos directamente boolean valores como condicionales, como en estos ejemplos, sino que usamos una expresión:

if (username != null)
    System.out.println(username);
if (argument >= 10)
    System.out.println("The input is higher or equal than 10");

Si la expresion es false, el código perteneciente al if declaración simplemente se omite:

if (1 > 5)
    System.out.println("Hello");
System.out.println(" World!");

Y la salida es:

 World!

La declaración if-else

Muchas veces no querrá simplemente omitir un fragmento de código si la expresión se evalúa como false. Normalmente, queremos hacer algo else en ese caso:

if (expression) {
    // Code that executes only if the expression is true
}
else { // Optional
    // Code that executes only if the expression is false
}

Por supuesto, puede utilizar el else declaración junto con la abreviatura if declaración:

Te puede interesar:Control de flujo de Java: romper y continuar declaraciones

if (expression)
    // Code that executes only if the expression is true
else
    // Code that executes only if the expression is false

Sin embargo, esto no es recomendable si no está tratando con declaraciones simples, especialmente con anidadas. ifs ya que es difícil averiguar «cuál if hace un particular else pertenecen a «. El uso de corchetes eliminará la ambigüedad del problema si encuentra este enfoque ilegible.

los else declaración de declaración es opcional, por lo que no es necesario escribir un vacío else {} bloquear si no queremos que pase nada si es el expression Es falso.

los else declaración está intrínsecamente ligada a la if declaración y no puede existir sin ella. Eso debe aparecer justo después del if de lo contrario, aparecerá un error del compilador «else without if».

En muchos casos, queremos comparar algo para la igualdad, si una variable tiene el mismo valor que otra o si es más pequeña o más grande que otra. Por ejemplo:

String s = "smol";

if (s.length() > 8)
    System.out.println("Variable s has too many characters!");
else
    System.out.println("Ok, so basically, s is very " + s);

los > operador aquí tiene el significado habitual «mayor que», y Java admite el grupo habitual de operadores relacionales. Éstas incluyen <, >, <=, =>, == verifica la igualdad y != comprueba la desigualdad.

Nota: Asegúrate de usar == en if declaraciones en lugar de =o bien puede asignar un valor en lugar de compararlo.

Te puede interesar:Java: lista de archivos en un directorio

2 < 5   // true
2 < 2   // false
2 <= 2  // true
2 == 3  // false
2 != 3  // true

Nota: La mayor parte del tiempo, no comparamos String variables usando == pero con el .equals() método. == comprueba la igualdad de referencia del objeto. Para tipos primitivos (int, char, etc.) es lo mismo que comprobar si tienen el mismo valor, pero con Strings lo más común es que no lo sea.

if (string1.equals(string2))
    // Code to be executed if the strings are equal by value

Declaraciones if anidadas

Podemos tener mas de uno if declaración conectada, ya sea anidando (poniendo una if declaración dentro de otra) o agregando una else if al final de nuestro anterior if:

int ourNumber = 10;

if (ourNumber > 8) {
    if (ourNumber % 2 == 0) {
       System.out.println("The number is larger than 8 and even");
    }
}
else if (ourNumber == 1) {
    System.out.println("1 is less than 8, so the previous if block isn't executed");
}
else {
    System.out.println("ourNumber is less than 8 and different than 1");
}

los else los bloques siempre «pertenecen» a la if del mismo nivel, por lo que else if (ourNumber == 1) en nuestro código pertenece al if (ourNumber > 8) y no el anidado if que comprueba si el número es par.

Puedes tener tantos else if bloques como quieras, pero solo uno else bloque, que debe ser el último. Solo el primero de los if, else if y else bloques que se evalúan como verdadero ejecutarán su código:

if (expression)
    // If expression is true, execute
else if (expression2)
    // If expression2 is true, execute
else if (expression3)
    // If expression3 is true, execute
...
else (expression4)
    // If expression4 is true, execute

Varias expresiones en una sola declaración if

Otra cosa muy útil es la capacidad de verificar múltiples condiciones en una sola if:

int ourNumber = 10;

if (ourNumber > 5 && (ourNumber % 2 == 0)) {
    System.out.println("The number is larger than 8 and even");
}

los && El operador es uno de los operadores logicos Soporta Java. En los siguientes ejemplos boolExpr se usa como abreviatura de boolean expression. Recordatorio: a boolean expresión es una expresión que se puede evaluar como true o false, es decir, también puede ser una expresión que contenga un operador lógico, como podemos ver aquí:

Te puede interesar:Gráficos en Java

• !boolExpr: ! es negación, evalúa un true expresión a false y viceversa.
• boolExpr1 & boolExpr2: la Y operador evalúa a true si ambas expresiones son true.
• boolExpr1 | boolExpr2: la O operador evalúa a true si al menos una de las expresiones es true.
• boolExpr1 && boolExpr2: el cortocircuito Y operador evalúa a true sólo si boolExpr1 y boolExpr2 son ambos true. Se llama operador de cortocircuito porque si la primera expresión es false, ni siquiera evaluará la segunda expresión como la condición básica de que ambos deben ser true nunca puede ocurrir. Con expresiones simples, esto no afecta el código de manera significativa, pero en el código de producción, ambas expresiones pueden ser operaciones costosas y este enfoque puede optimizar significativamente el código.
• boolExpr1 || boolExpr2: el cortocircuito O operador evalúa a true si al menos uno de boolExpr1 y boolExpr2 es true. Una versión de cortocircuito del | operador.
• boolExpr1 ^ boolExpr2: la XOR operador evalúa a true sólo si boolExpr1 y boolExpr2 se evalúan de manera diferente, es decir, si solo uno de ellos es true y el otro es false.

true && false // false
(2 < 5) && (2 != 3) // true
false || true //true
true && ((false || false) ^ true) // true
(true && false) || false // false

Es muy recomendable usar paréntesis siempre que tenga sentido usarlos. El último ejemplo funciona igual sin paréntesis, pero confiando en precedencia del operador es extremadamente arriesgado y conduce a un código ilegible.

Construcciones ternarias

El único operador ternario (un operador que toma tres operandos) en Java se compone de la ? y : operadores. Funciona como un muy compacto if-else declaración.

// The if-statement below...
int max = 0;
if (a > b)
    max = a;
else max = b;

// ...can be written as:
int max = (a > b) ? a : b;

Así es como se ve generalmente una construcción ternaria:

(expression) ? returnValueIfTrue : returnValueIfFalse

Las construcciones ternarias también pueden funcionar sin paréntesis, aunque generalmente es más legible usar paréntesis:

int max = a > b ? a : b;

También puede utilizar construcciones ternarias para modificar variables:

System.out.println("10% discount for orders above $50!");
double orderPrice = 55;
double finalPrice = orderPrice > 50 ? orderPrice*0.9 : orderPrice;
System.out.println("Your final price is $" + finalPrice);

Y la salida es:

Te puede interesar:Trabajar con PostgreSQL en Java

Your final price is $49.5

Usando la construcción, también podemos llamar a métodos:

public void someMethod() {
    String userRole = "Admin";
    String result = userRole.equals("Admin") ? greetAdmin() : greetUser();
    System.out.println(result);
}

static String greetAdmin() {
    return "Hello Admin!";
}

static String greetUser() {
    return "Hello User!";
}

Lógicamente, esto resultaría en:

Hello Admin!

Construcciones ternarias anidadas

System.out.println("10% discount for all orders above $50 and additional $5 off if your order exceeds 2 items!");
double orderPrice = 140;
int quantity = 5;
double finalPrice = (orderPrice > 50) ? (quantity > 2) ? (orderPrice*0.9)-5 : orderPrice*0.9 : orderPrice;
System.out.println("Your final price is: $" + finalPrice);

Dado que ambas condiciones son true, la salida es:

10% discount for all orders above $50 and additional $5 off if your order exceeds 2 items!
Your final price is: $121.0

Sin embargo, este enfoque es terriblemente ilegible. Si es posible, evite anidar construcciones ternarias, aunque si es necesario, divídalo en bloques más simples con nuevas líneas y sangría. Por ejemplo, este ejemplo se puede hacer un poco más legible:

System.out.println("10% discount for all orders above $50 and additional $5 off if your order exceeds 2 items!");
double orderPrice = 140;
int quantity = 5;
double finalPrice = (orderPrice > 50) ?
                        (quantity > 2) ?
                                (orderPrice*0.9)-5 : orderPrice*0.9
                    : orderPrice;
System.out.println("Your final price is: $" + finalPrice);

Conclusión

El control de flujo en el código es esencial para absolutamente todas las aplicaciones. Declaraciones como if y if-else son bloques de construcción fundamentales y todo desarrollador aspirante debe tener el control total / ser consciente de cómo funcionan.

 

Te puede interesar:Colecciones Java: la interfaz del mapa