Java: Instrucciones de control alternativas

Las instrucciones de control alternativas o condicionales permiten determinar el flujo de ejecución de un programa evaluando una condición lógica.

Existen cuatro instrucciones de control condicionales en Java: if, if-else, switch y el operador ternario.

Instrucción If

Evalúa una condición lógica y, solo si esta se cumple, se ejecutará cierto bloque de instrucciones. En caso de que la condición tenga valor false, dicho bloque de instrucciones se ignorará.

Sintaxis:

bloque 1
if (condición) {
    bloque 2
}
bloque 3

La instrucción if evalúa la condición lógica definida entre paréntesis. Si esta devuelve valor true se ejecutará el bloque de instrucciones definidas entre llaves (bloque 2). Si la condición no se cumple (devuelve valor false) no se ejecutará ninguna de las instrucciones definidas entre las llaves.

Todas las instrucciones definidas antes (bloque 1) y después (bloque 3) de la instrucción if (es decir, todo lo que está fuera de las llaves) se ejecutarán siempre. No les afecta la condición y se ejecutarán de forma secuencial: bloque 1 – if – bloque 3.

Ejemplo:

En el siguiente código podemos identificar:

• bloque 1:
  System.out.println («Inicio del programa»);
  int edad = 20;
• condición: edad >= 18
• bloque 2: System.out.println («Mayor de edad»);
• bloque 3: System.out.println («Fin del programa»);

//bloque 1
System.out.println ("Inicio del programa");
int edad = 20; 
if (edad >= 18){ //condición
    //bloque 2
    System.out.println ("Mayor de edad"); 
}
//bloque 3
System.out.println ("Fin del programa");

El bloque 1 y el bloque 3 se encuentran fuera de la instrucción if, así que se ejecutan siempre.

El bloque 2 está dentro de las llaves de la instrucción if, por lo que hay que evaluar la condición. La variable edad tiene valor 20, por lo que 20 >= 18 es cierto (true). Como la condición se cumple, se ejecuta el bloque 2.

El resultado que se mostraría por pantalla tras la ejecución sería:

Inicio del programa
Mayor de edad
Fin del programa

Si edad tuviese otro valor, por ejemplo 10:

//bloque 1
System.out.println ("Inicio del programa");
int edad = 10; 
if (edad >= 18){ //condición
    //bloque 2
    System.out.println ("Mayor de edad"); 
}
//bloque 3
System.out.println ("Fin del programa");

La condición no se cumple porque 10 >= 18 es falso (false). En este caso el bloque 2 no se ejecuta y la salida por pantalla sería:

Inicio del programa
Fin del programa

Nota: Si el bloque de la instrucción if solo contiene una instrucción, las llaves se pueden eliminar. En el ejemplo quedaría así:

//bloque 1
System.out.println ("Inicio del programa");
int edad = 20; 
if (edad >= 18) //condición
    //bloque 2
    System.out.println ("Mayor de edad"); 
//bloque 3
System.out.println ("Fin del programa");

Intrucción if-else

La instrucción if se puede complementar con la instrucción else para definir un bloque de instrucciones que se ejecutará en caso de que la condición evaluada no se cumpla.

La instrucción else no puede usarse si no existe una instrucción if previa que determine la condición.

Sintaxis:

bloque 1
if (condición) {
    bloque 2
}else{
    bloque 3
}
bloque 4

Los bloques 1 y 4 se encuentran fuera de las llaves de la instrucción if y de la instrucción else, por lo que se ejecutarán siempre. Son independientes de la condición.

El bloque 2 sólo se ejecutará si la condición que evalúa la instrucción if es cierta. En ese caso las instrucciones encerradas entre las llaves del else (bloque 3) no se ejecutarán.

Si la condición no se cumple, el bloque 2 se ignorará y se ejecutará el bloque 3.

No existe ningún caso en el que se ejecuten el bloque 2 y el 3. Son excluyentes entre si. Si uno se ejecuta el otro no lo hará.

Ejemplo:

En el siguiente código podemos identificar:

• bloque 1:
  System.out.println («Inicio del programa»);
  int edad = 20;
• condición: edad >= 18
• bloque 2: System.out.println («Mayor de edad»);
• bloque 3: System.out.println («Menor de edad»);
• bloque 4: System.out.println («Fin del programa»);

//bloque 1
System.out.println ("Inicio del programa");
int edad = 10; 
if (edad >= 18){ //condición
    //bloque 2
    System.out.println ("Mayor de edad"); 
} else {
    //bloque 3
    System.out.println ("Menor de edad");
}
//bloque 4
System.out.println ("Fin del programa");

El bloque 1 y el bloque 4 se encuentran fuera de la instrucción if y de la instrucción else, así que se ejecutan siempre.

El bloque 2 está dentro de las llaves de la instrucción if, por lo que hay que evaluar la condición. La variable edad tiene valor 10, por lo que 10 >= 18 es falso (false). Como la condición no se cumple, no se ejecuta el bloque 2, pero si se ejecuta el bloque 3 que está dentro de las llaves de la instrucción else.

El resultado que se mostraría por pantalla tras la ejecución sería:

Inicio del programa
Menor de edad
Fin del programa

Si cambiamos el valor de edad por otro, por ejemplo 30:

//bloque 1
System.out.println ("Inicio del programa");
int edad = 30; 
if (edad >= 18){ //condición
    //bloque 2
    System.out.println ("Mayor de edad"); 
} else {
    //bloque 3
    System.out.println ("Menor de edad");
}
//bloque 4
System.out.println ("Fin del programa");

La condición se cumple porque 30 >= 18 es cierto (true). En este caso ocurriría todo lo contrario. El bloque 2 se ejecuta y el bloque 3 no.

La salida por pantalla sería:

Inicio del programa
Mayor de edad
Fin del programa

Nota: Al igual que ocurría con el if, en el else también se pueden eliminar las llaves si el bloque solo contiene una instrucción. El ejemplo quedaría así:

//bloque 1
System.out.println ("Inicio del programa");
int edad = 10; 
if (edad >= 18) //condición
    //bloque 2
    System.out.println ("Mayor de edad"); 
else
    //bloque 3
    System.out.println ("Menor de edad");
//bloque 4
System.out.println ("Fin del programa");

Intrucción Switch

A diferencia de las instrucciones anteriores, esta no evalúa una condición lógica, sino que evalúa un valor de tipo entero primitivo (char, byte, short o int), wrapper* (Character, Byte, Short o Integer), cadena* (String) o enumeración*.

*Algunos de estos tipos los veremos más adelante.

La instrucción tendrá definidos ciertos casos que se ejecutarán dependiendo del valor evaluado.

Sintaxis:

bloque 1
switch (valor){
    case val1: bloque val1;
    break;
    case val2: bloque val2;
    break;
    ...
    case valN: bloque valN;
    break;
    default: bloque def;
    break;
}
bloque 2

Las instrucciones externas (bloque 1 y bloque 2) se ejecutan siempre.

Cada caso se define con la palabra reservada case seguida de un valor del mismo tipo que el que se está evaluando. Cuando el valor indicado en un case es igual que el que se evalúa, se ejecutará el bloque de instrucciones definido entre los dos puntos (:) y la instrucción break.

La instrucción break evita que se ejecute el siguiente caso definido (si hay), terminando la ejecución de la instrucción switch. Si queremos que se ejecute más de un caso no habría que poner break y se ejecutarían los siguientes casos hasta encontrar otro break o terminar el switch.

Existe un caso particular que se ejecutará cuando ninguno de los demás casos definidos tengan un valor igual al evaluado. Se declara con la palabra reservada default, aunque su uso no es obligatorio. El funcionamiento es el mismo que los case.

Ejemplo:

En el siguiente código podemos identificar:

• bloque 1:
  System.out.println («Inicio del programa»);
  int x = 3;
• valor: x
• casos: case 1, case 2 y default
• bloque 2: System.out.println («Fin del programa»);

//bloque 1
System.out.println ("Inicio del programa");
int x = 3;
//valor que evalua el switch
switch (x){
    //casos
    case 1: System.out.println ("x vale 1");
    break;
    case 2: System.out.println ("x vale 2");
    break;
    case 3: System.out.println ("x vale 3");
    break;
    //caso por defecto
    default: System.out.println ("x tiene otro valor no contemplado");
}
//bloque 2
System.out.println ("Fin del programa");

Los bloques de instrucciones 1 y 2 se ejecutarán indistintamente de lo que ocurra con el switch.

La intrucción switch evalúa el valor de la variable x, declarada e inicializada previamente con valor 3.

Dentro de las llaves de la instrucción switch hay un case cuyo valor es igual al de la variable x: case 3. Por tanto, se ejecutarán las instrucciones definidas entre los dos puntos (:) y la instrucción break de dicho case, es decir: System.out.println («x vale 3»).

La salida completa sería:

Inicio del programa
x vale 3
Fin del programa

Supongamos ahora que dentro del switch no hubiese ningún case con valor 3:

//bloque 1
System.out.println ("Inicio del programa");
int x = 3;
//valor que evalua el switch
switch (x){
    //casos
    case 1: System.out.println ("x vale 1");
    break;
    case 2: System.out.println ("x vale 2");
    break;
    //caso por defecto
    default: System.out.println ("x tiene otro valor no contemplado");
}
//bloque 2
System.out.println ("Fin del programa");

El resto de case no tienen valor igual al evaluado, es decir, el de la variable x, por tanto, se ejecutaría el caso por defecto (default).

La salida entonces sería esta:

Inicio del programa
x tiene otro valor no contemplado
Fin del programa

¿Y si no hubiese default? Entonces el bloque switch se ignoraría entero puesto que ningún caso sería igual al valor evaluado.

La salida quedaría así:

Inicio del programa
Fin del programa

Veamos ahora un ejemplo en el que sería muy útil quitar el break. El objetivo de este fragmento de código es indicar el número de días que tiene un mes:

System.out.println ("Inicio del programa");
int mes = 5;
switch (mes){
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12: System.out.println ("Mes con 31 días");
    break;

    case 2: System.out.println ("Mes con 28 o 29 días");
    break;

    case 4:
    case 6:
    case 9:
    case 11: System.out.println ("Mes con 30 días");
    break;

    default: System.out.println ("Mes incorrecto");
}
System.out.println ("Fin del programa");

Antes del switch está declarada la variable entera mes e inicializada con valor 5: int mes = 5.

Dentro del switch existe un case para el valor 5, pero no tiene código. Si nos fijamos no es el único, hay unos cuantos más que van consecutivos hasta el case 12, justo los meses que tienen 31 días. Este último case si tiene código y una instrucción break justo a continuación. Cuando se evalúe la variable mes se ejecutará el case 5 y como no tiene break continuará ejecutando los siguientes casos hasta encontrar un break, es decir, case 5, case 7, case 8, case 10 y case 12.

¿Qué conseguimos con esto? Agrupar todos los casos que comparten las mismas instrucciones para evitar repetirlas.

La salida quedaría así:

Inicio del programa
Mes con 31 días
Fin del programa

Operador ternario

El operador ternario no es una instrucción de control como tal, es un operador, pero su ejecución es muy similar a un if else, por eso lo he incluido en este artículo.

Es el único operador en Java que tiene tres operandos, de ahí su nombre. Uno de estos operandos será una expresión lógica (true o false) que será evaluada por el operador. El resultado de esta evaluación determinará cuál de los otros dos operandos se ejecutará.

Sintaxis:

condición ? operandoT : operandoF

La expresión lógica siempre va antes del operador (?). Si la evaluación es true se ejecuta el operando situado entre el operador (?) y los dos puntos (:). En caso de ser falsa se ejecuta el operando situado tras los dos puntos (:). Nunca se ejecutarán los dos operandos (operandoT y operandoF), son excluyentes, dependen siempre de la condición evaluada.

Ejemplo:

En el siguiente código podemos identificar:

• condición: a==0
• operandoT: b
• operandoF: c

int a = 0;
int b = 4;
int c = 2;
        
System.out.println(a==0 ? b : c);

El operador evalúa la expresión a==0. La variable a ha sido declarada previamente e inicializada con valor 0, por tanto, el resultado de la evaluación será true. En este caso se ejecutará lo que hay entre el operador ? y los dos puntos (:), la variable b que tiene valor 4. Esa será la salida.

Si a tuviese otro valor, por ejemplo 3:

int a = 3;
int b = 4;
int c = 2;
        
System.out.println(a==0 ? b : c);

La evaluación ya no sería cierta y sería la variable c la que se ejecutase. La salida entonces sería el valor de dicha variable: 2.

Sígueme: