Estructura condicional en Java

En este tema continuamos con las estructuras de control y estudiaremos a fondo la estructura condicional en Java.

La estructura condicional, también llamada estructura alternativa o selectiva, es una de las estructuras de control que permiten modificar el orden de ejecución de las instrucciones de un programa.

La estructura condicional determina si se ejecutan unas instrucciones u otras según se cumpla o no una determinada condición.

La condición que se comprueba para decidir si unas instrucciones se ejecutan o no debe ser una expresión booleana es decir debe dar como resultado un valor booleano true ó false.

En java la estructura de control condicional se implementa utilizando:

• Instrucciones if
• Estructuras switch
• El operador ternario ? :

La instrucción if es una estructura de control condicional que se utiliza para ejecutar unas instrucciones u otras, dependiendo de si una condición se cumple o no.

La instrucción if puede ser del tipo:

• Condicional simple
• Condicional doble
• Condicional múltiple (instrucciones if anidadas)

La estructura condicional simple, es la estructura de control condicional más sencilla en Java. La usaremos para decidir si una instrucción o bloque de instrucciones se ejecuta o no dependiendo de una condición.

Su funcionamiento es el siguiente:

• Se evalúa la condición
• Si la condición se cumple se ejecuta la instrucción o bloque de instrucciones
• Si no se cumple se salta ese bloque de instrucciones y el programa continúa al continuación de la instrucción if.
• Diagrama de flujo de la estructura condicional simple:

De forma gráfica podemos representar la estructura condicional simple de la siguiente forma:

En el diagrama de flujo podemos ver el flujo de ejecución del programa. Se ejecutan las instrucciones 1 y 2 y se llega a la condición. Si la condición es cierta se ejecutan las instrucciones 3 y 4 y el programa continúa con el resto de instrucciones. Si la instrucción no se cumple, se saltan las instrucciones 3 y 4 y el programa continúa su ejecución a partir de la instrucción 5.

Sintaxis de la estructura condicional simple en Java:

En Java para crear una estructura condicional simple se utiliza la palabra reservada if seguida de la condición entre paréntesis. A continuación de la condición se escriben entre llaves { } el bloque de instrucciones que se deben ejecutar si la condición se cumple.

Si el bloque de instrucciones a ejecutar está formado por una sola instrucción, las llaves se pueden omitir aunque es recomendable escribirlas para evitar confusiones.

El ejemplo mostrado en el diagrama de flujo sería este:

instrucción 1;
instrucción 2;
if(condición){    // inicio de la estructura condicional simple
   instrucción 3;
   instrucción 4;
} // fin de la estructura condicional simple
instrucción 5;
instrucción 6;                

Ejemplo 1:

Programa que pide que se introduzca una nota por teclado y muestra dos mensajes si la nota es mayor o igual a 5.

/*
 *  Ejemplo de estructura alternativa simple en Java
 *  Programa que pide una nota por teclado y muestra dos mensajes 
 *  si la nota es mayor o igual que 5
 */
import java.util.Scanner;
public class CondicionalSimple1 {
     public static void main( String[] args ){
                Scanner sc = new Scanner( System.in );
                System.out.print("Introduce nota: ");
                int nota = sc.nextInt();
                if (nota >= 5){  //-------inicio de la instrucción if
                      System.out.println("Enhorabuena!!");
                      System.out.println("Has aprobado");
                } //----------------------fin de la instrucción if
                System.out.println("Hasta Pronto!");
     }
}

En este ejemplo si se introduce un número >= 5 el programa mostrará:

Enhorabuena!!     
Has aprobado
Hasta Pronto! 

Si introducimos un valor < 5 la condición no se cumple por lo que solo mostrará el mensaje:

Hasta Pronto! 

Como se ha indicado anteriormente, si un bloque de instrucciones contiene una sola instrucción no es necesario escribir las llaves { } .

Por ejemplo, supongamos que en el ejemplo anterior queremos mostrar solo el mensaje Enhorabuena! si la nota es >= 5. El bloque de instrucciones que se deben ejecutar cuando la condición se cumple está formado ahora por una única instrucción por lo que la instrucción if la podemos escribir sin las llaves. El programa quedaría así:

import java.util.Scanner;
public class CondicionalSimple1 {
     public static void main( String[] args ){
                Scanner sc = new Scanner( System.in );
                System.out.print("Introduce nota: ");
                int nota = sc.nextInt();
                if (nota >= 5)
                      System.out.println("Enhorabuena!!");
                System.out.println("Hasta Pronto!");
     }
}

Ahora si se introduce un número >= 5 el programa mostrará:

Enhorabuena!!     
Hasta Pronto! 

Si introducimos un valor < 5 mostrará:

Hasta Pronto! 

No escribir las llaves cuando una estructura condicional contiene una sola instrucción puede conducir a un código confuso de entender por lo que es siempre recomendable escribir las llaves incluso en los casos en los que no sea necesario.

Ten en cuenta que el código no es obligatorio escribirlo con ese formato en el que las instrucciones están tabuladas. Aunque no es un buen estilo de programación, se podría haber escrito así:

if (nota >= 5)
System.out.println("Enhorabuena!!");
System.out.println("Hasta Pronto!");

Escribiéndolo así omitiendo las llaves puede llevar a confusión al no estar claro a simple vista donde comienza el bloque if y donde acaba. Por eso es recomendable escribir siempre las llaves.

La estructura condicional doble hace posible que el flujo de ejecución del programa pueda seguir dos caminos distintos dependiendo del valor de una condición.
Se evalúa la condición y si se cumple se ejecuta una determinada instrucción o grupo de instrucciones. Si no se cumple se ejecuta otra instrucción o grupo de instrucciones.

Funciona de la siguiente forma:

• Se evalúa la condición.
• Si se cumple se ejecuta una determinada instrucción o bloque de instrucciones.
• Si no se cumple se ejecuta otra instrucción o grupo de instrucciones.
• El programa continúa su ejecución por la siguiente instrucción a continuación de la instrucción if.

Diagrama de flujo de la estructura de control condicional doble:

Se ejecutan las instrucciones 1 y 2 y se llega a la condición. Si la condición es cierta se ejecutan las instrucciones 3 y 4. Si la condición no se cumple se ejecutan las instrucciones 5 y 6. En ambos casos el programa continúa su ejecución con las instrucciones 7 y 8.

Sintaxis de la estructura condicional doble en Java:

La estructura condicional doble en Java se construye utilizando las palabras if else. Se escribe if y a continuación, entre paréntesis, se escribe la condición. A continuación de la condición se escriben entre llaves { } el bloque de instrucciones que se deben ejecutar si la condición es true. A continuación se escribe la palabra else y entre llaves las instrucciones que se ejecutan si la condición es false.

El ejemplo mostrado en el diagrama de flujo se escribiría así:

instrucción 1;
instrucción 2;
if(condición){    // inicio de la estructura condicional doble
    //instrucciones que se ejecutan cuando la condición es true
    instrucción 3;
    instrucción 4;
} else {
   //instrucciones que se ejecutan cuando la condición es false
   instrucción 5;
   instrucción 6;                
}
instrucción 7;
instrucción 8;

Ejemplo 1:

Programa que lee una nota por teclado y muestra un mensaje indicando si se ha aprobado o no.

Si la nota es >= 5 mostrará los mensajes:

Enhorabuena!!
Has aprobado

Si la nota es < 5 se mostrará el mensaje:

Lo siento, has suspendido

En ambos casos se mostrará a continuación el mensaje:

Hasta Pronto!

/*
 *  Ejemplo de estructura alternativa doble en Java
 *  Programa que pide una nota por teclado y muestra si se ha aprobado o no
 */
import java.util.Scanner;
public class CondicionalDoble1 {
     public static void main( String[] args ){
                Scanner sc = new Scanner( System.in );
                System.out.print("Introduce nota: ");    
                int nota = sc.nextInt();
                if (nota >= 5){
                    System.out.println("Enhorabuena!!");
                    System.out.println("Has aprobado");
                } else {
                    System.out.println("Lo siento, has suspendido");
                }       
                System.out.println("Hasta Pronto!");
     }
}

Ejemplo 2:

Programa que lee un número entero por teclado y muestra un mensaje indicando si el número es par o impar.

/*
 *  Ejemplo de estructura alternativa doble en Java
 *  Programa que pide un número por teclado y muestra si es par o impar
 */
import java.util.Scanner;
public class CondicionalDoble1 {
     public static void main( String[] args ){
                Scanner sc = new Scanner( System.in );
                System.out.print("Introduce un número entero: ");    
                int numero = sc.nextInt();
                if (num % 2 == 0){
                    System.out.println("PAR");
                } else {
                    System.out.println("IMPAR");
                }       
     }
}

Mediante esta estructura podemos construir estructuras de selección más complejas.

La estructura de control condicional múltiple se obtiene encadenando sentencias if … else.

Un ejemplo de estructura condicional múltiple, expresado en diagrama de flujo, puede ser este:

En el diagrama podemos seguir el flujo de ejecución de las instrucciones. Se ejecuta la instrucción 1 y se llega a la condición 1. Si condición 1 es cierta se ejecutan las instrucciones 2 y 3 y el programa continúa su ejecución por la instrucción 10. Si condición 1 es false se evalúa la condición 2. S condición 2 es true se ejecuta la instrucción 4 y el programa continúa por la instrucción 10. Si condición 2 es false se evalúa la condición 3, si es true se ejecutan las instrucciones 5, 6, y 7 y se continúa por la instrucción 10. Si la condición 3 es false se ejecutan las instrucciones 8 y 9 e se continúa la ejecución por la instrucción 10.

En este ejemplo se han encadenado 3 condiciones pero podemos anidar tantas como necesitemos.

Sintaxis de la estructura condicional múltiple en Java:

La sintaxis para la estructura condicional múltiple en Java es la siguiente:

Como vemos, la estructura condicional múltiple se forma mediante instrucciones if .. else anidadas.

Cada else se corresponde con el if más próximo que no haya sido emparejado.

Una vez que se ejecuta uno de los bloques de instrucciones, la ejecución del programa continúa en la siguiente instrucción que aparezca después de la estructura condicional múltiple.

Ejemplo 1:

Programa Java que pide que se introduzca una hora y muestra un mensaje según la hora introducida corresponda a la mañana, la tarde o la noche. Si la hora introducida no es válida se mostrará un mensaje indicándolo. Se considera una hora válida si su valor está comprendido entre 0 y 23 ambos incluidos.

/*
 *  Ejemplo de estructura alternativa múltiple en Java
 *  Programa que muestra un saludo distinto según la hora introducida
 */
import java.util.Scanner;
public class EjemploIfAnidados {
     public static void main(String[] args) {
               Scanner sc = new Scanner(System.in);
               int hora;
               System.out.print("Introduzca una hora (>= 0 y <= 23): ");
               hora = sc.nextInt();
               if (hora >= 0 && hora < 12) {
                   System.out.println("Buenos días");
               } else if (hora >= 12 && hora < 21) {
                    System.out.println("Buenas tardes");
               } else if (hora >= 21 && hora < 24) {
                    System.out.println("Buenas noches");
               } else {
                    System.out.println("Hora no válida");
               }
               System.out.println("Hasta pronto!!!");
     }
}

Cuatro ejemplos de ejecución del programa:

Introduzca una hora (>= 0 y <= 23): 6
Buenos días
Hasta pronto!!!

Introduzca una hora (>= 0 y <= 23): 21
Buenas noches
Hasta pronto!!!

Introduzca una hora (>= 0 y <= 23): 25
Hora no válida
Hasta pronto!!!

Introduzca una hora (>= 0 y <= 23): 13
Buenas tardes
Hasta pronto!!!

En estos ejemplos podemos comprobar que una vez que se ejecuta una de las instrucciones dentro del bloque de if anidados, la ejecución del programa continúa en la siguiente instrucción a continuación del bloque de if anidados, en este caso la ejecución sigue por la instrucción

System.out.println("Hasta pronto!!!");

Ejemplo 2:

Programa que pide que se introduzca un valor numérico de tipo double correspondiente a la nota de un alumno en una determinada asignatura y muestra un texto con la calificación equivalente de la siguiente forma:
Si la nota es menor que 5 muestra “Suspenso”
Si la nota es mayor o igual que 5 y menor que 6 muestra “Suficiente”
Si la nota es mayor o igual que 6 y menor que 7 muestra “Bien”
Si la nota es mayor o igual que 7 y menor que 9 muestra “Notable”
Si la nota es mayor o igual que 9 y menor que 10 muestra “Sobresaliente”
Si la nota es igual a 10 muestra “Matrícula de honor”
Si la nota es menor que 0 o mayor que 10 mostrará el mensaje “Nota no válida”

/*
 *  Ejemplo de estructura alternativa múltiple en Java
 *  Programa que lee una nota numérica y muestra su equivalente en texto
 */
import java.util.Scanner;
public class EjemploIfAnidados {
     public static void main(String[] args) {
               Scanner sc = new Scanner(System.in);
               double nota;
               System.out.println("Introduzca una nota entre 0 y 10: ");
               nota = sc.nextDouble();
               System.out.println("La calificación del alumno es ");
               if (nota < 0 || nota > 10) {
                   System.out.println("Nota no válida");
               } else if (nota == 10) {
                   System.out.println("Matrícula de Honor");
               } else if (nota >= 9) {
                   System.out.println("Sobresaliente");
               } else if (nota >= 7) {
                   System.out.println("Notable");
               } else if (nota >= 6) {
                   System.out.println("Bien");
               } else if (nota >= 5) {
                   System.out.println("Suficiente");
               } else {
                   System.out.println("Suspenso");
               }
     }
}

Al utilizar la estructura condicional en Java, es frecuente cometer errores de sintaxis y de lógica, especialmente si estamos empezando a programar.

Los errores más comunes que se suelen producir son los siguientes:

por ejemplo, si queremos comprobar si el valor de la variable nota es igual a 6 y escribimos:

if (nota = 6)    
   System.out.println("Bien");

estamos utilizando el operador de asignación = en lugar del operador de comparación ==

Lo correcto es escribir la instrucción if de esta forma:

if (nota == 6)    
   System.out.println("Bien");

Por suerte la mayoría de entornos de desarrollo nos avisarán de este error, por ejemplo NetBeans nos avisará con este mensaje:

Nos está indicando que un int no se puede convertir en un boolean. En la condición lo que estamos haciendo es asignar el valor 6 a la variable nota cuando lo correcto dentro de la condición es comparar si el valor de nota es igual a 6 y así obtener un valor boolean true o false.

Este error se produce muy a menudo cuando estamos a programar con el lenguaje ya que en java la mayoría de instrucciones finalizan con el carácter ; pero no es así con las instrucciones if.

Por ejemplo, si ejecutamos las instrucciones:

int nota = 0;
if (nota > 6); 
   System.out.println("Notable");

Se muestra por pantalla:

Notable

este caso el ; después de la condición if(nota > 6); provoca que instrucción if finalice en ese punto por lo que el mensaje «Notable» se mostrará siempre, sea cual sea el valor de nota.

En este otro caso:

int nota = 0;
if (nota >= 5); {
     System.out.println("Enhorabuena!!");
     System.out.println("Has aprobado");
}

El ; después de la condición hace que el if finalice. El bloque de instrucciones entre llaves deja de estar asociado al if y se ejecutará siempre sin importar el valor de la variable nota.

Se muestra por pantalla:

Enhorabuena!!
Has aprobado

En Java, las llaves { } delimitan el bloque de instrucciones que se ejecutará cuando se cumpla o no una condición. Si se omiten las llaves, el if o el else solo afecta a la siguiente instrucción.

Por ejemplo, al ejecutar las instrucciones:

int nota = 0;
if (nota >= 5)
     System.out.println("Enhorabuena!!");
     System.out.println("Has aprobado");
System.out.println("Fin programa");

Se muestra por pantalla:

Has aprobado
Fin programa

La ausencia de llaves después de la condición if (nota >= 5) provoca que la instrucción System.out.println(«Has aprobado»); se ejecute siempre sea cual sea el valor de la variable nota.

Lo correcto es escribir la condición de esta forma:

int nota = 0;
if (nota >= 5) {
    System.out.println("Enhorabuena!!");
    System.out.println("Has aprobado");
}
System.out.println("Fin programa");

Un error frecuente entre los principiantes consiste en intentar comprobar si un valor se encuentra dentro de un intervalo utilizando una expresión como lo haríamos en matemáticas. Sin embargo, Java no permite realizar este tipo de comparaciones de la misma forma que en matemáticas.

Por ejemplo, para saber si una nota está entre 0 y 10, en matemáticas lo expresamos de esta forma: 0 <= nota <= 10

Pero en Java no se puede escribir la condición de esa forma como en matemáticas:

if (0 <= nota <= 10) {   // Error de compilación
    System.out.println("Nota válida");
}

Esa forma de escribir la condición provoca un error de compilación.

La forma correcta consiste en realizar las dos comparaciones por separado y combinarlas mediante el operador lógico &&:

if (nota >= 0 && nota <= 10) {   
    System.out.println("Nota válida");
}

Cuando se crea una estructura condicional múltiple mediante if anidados o encadenados, el orden en el que se escriben las condiciones puede afectar al resultado, pudiendo obtener resultados no válidos.

Por ejemplo:

if (nota >= 5) {
    System.out.println("Aprobado");
} else if (nota >= 7) {
    System.out.println("Notable");
} else if (nota >= 9) {
   System.out.println("Sobresaliente");
}

Este código nunca mostrará los mensajes Notable o Sobresaliente ya que cualquier nota que sea >= 7 o >= 9 cumple la primera condición nota >= 5. Para cualquier nota que sea >= 5 siempre se mostrará el mensaje Aprobado.

La forma correcta de escribir estas condiciones encadenadas es colocar las condiciones más restrictivas o específicas al principio dejando las más generales al final.

if (nota >= 9) {
    System.out.println("Sobresaliente");
} else if (nota >= 7) {
    System.out.println("Notable");
} else if (nota >= 5) {
    System.out.println("Aprobado");
}

Un error frecuente consiste en utilizar operadores como == para comparar el contenido de dos Strings. Pero debemos tener en cuenta que los String son objetos y los objetos en Java no se pueden comparar mediante los operadores relacionales ==, >, >= , !=, etc.

Por ejemplo, para comprobar si dos Strings son iguales, es un error escribir la condición de esta forma:

String nombre1 = new String("Juan");
String nombre2 = new String("Juan");
if(nombre1 == nombre2){
    System.out.println("Iguales");
}else{
    System.out.println("Distintos");
}

Al ejecutar las instrucciones se mostrará por pantalla el mensaje Distintos aunque su contenido sea el mismo.

Esto se debe a que los Strings son objetos y mediante el operador == estamos comprobando si la referencia de esos dos objetos es la misma. En definitiva estamos comprobando si ambos hacen referencia al mismo objeto.

Mediante los operadores relacionales se comprueban las referencias de los objetos no su contenido.

Para comparar Strings, Java proporciona una serie de métodos. Los más utilizados en general son estos:

• equals para comprobar si dos String son iguales.
• equalsIgnoreCase para comprobar si son iguales sin tener en cuenta mayúsculas o minúsculas.
• equalsFoldCase (a partir de Java 26) comprueba si son iguales teniendo en cuenta equivalencias del texto con caracteres Unicode.
• compareTo para ordenar cadenas en orden alfabético. Determina si una cadena es mayor, menor o igual a otra según el orden alfabético.
• compareToIgnoreCase para ordenar alfabéticamente sin tener en cuenta mayúsculas o minúsculas
• compareToFoldCase (a partir de Java 26) para ordenar alfabéticamente teniendo en cuenta equivalencias del texto con caracteres Unicode.

El ejemplo anterior para comprobar si los dos Strings contienen el mismo texto se debe escribir de la siguiente forma:

String nombre1 = new String("Juan");
String nombre2 = new String("Juan");
if(nombre1.equals(nombre2)){
   System.out.println("Iguales");
}else{
   System.out.println("Distintos");
}

El método equals comprueba si el contenido de ambos Strings es el mismo. En este caso se mostrará el mensaje Iguales.

En la entrada comparar dos Strings en Java se explica con más detalle la forma de comparar cadenas de texto en Java.

La estructura de control switch en Java se utiliza para seleccionar una opción de entre múltiples opciones posibles.

Es una alternativa a los if .. else anidados. Si el número de anidamientos if .. else es elevado, la estructura switch produce un código más sencillo de leer y modificar.

La estructura switch en Java ha ido evolucionando a lo largo del tiempo y en las últimas versiones del JDK se han ido incorporando funcionalidades que la acercan a una estructura más flexible y expresiva , permitiendo utilizarla no solo como una estructura de selección tradicional, sino también como una expresión capaz de producir un valor.

Como resultado de esta evolución a través de las distintas versiones de Java, a partir de Java 14 disponemos de dos tipos de switch:

• Instrucción switch. Es el switch clásico que se incorporó a Java desde la primera versión del lenguaje. Su principal función es controlar el flujo de ejecución del programa.
• Expresión switch. Consolidado a partir de Java 14. Además del controlar el flujo de ejecución, una expresión switch puede devolver un valor.

Ambas permiten seleccionar diferentes alternativas en función del valor de una expresión, pero presentan una diferencia fundamental: mientras que la instrucción switch se utiliza principalmente para controlar el flujo de ejecución y realizar determinadas acciones, la expresión switch permite además producir un valor como resultado. Esta última posibilidad facilita la escritura de código más compacto y permite utilizar switch directamente en asignaciones, declaraciones de variables o como parte de otras expresiones.

La instrucción switch es la instrucción de selección múltiple que Java incorporó desde sus primeras versiones y forma parte del lenguaje desde sus orígenes.

Una instrucción switch permite elegir entre diferentes bloques de instrucciones en función del valor obtenido al evaluar una expresión.

La sintaxis general de una instrucción switch en Java es la siguiente:

La sintaxis general de una instrucción switch en Java es la siguiente:

switch (expresión){
           case VALOR1:
                    instrucciones1;
                    break;
           case VALOR2:
                    instrucciones2;
                    break;
           // se pueden incluir tantos case como sean necesarios
           default:
                    instrucciones3;
}

El flujo de ejecución del programa lo determina el valor de una expresión llamada expresión de selección.

La instrucción switch en Java funciona de la siguiente forma:

• Primero se evalúa la expresión y la ejecución del programa continúa por el case cuyo valor coincida con el valor de la expresión.
• Se ejecutan las instrucciones que contiene el case seleccionado hasta que se encuentra un break o hasta el final del switch.
• El break produce un salto en la ejecución del programa. La ejecución continúa por la siguiente instrucción que se encuentre a continuación del switch.
• Si el valor de la expresión no coincide con ningún case se ejecuta el bloque default. El bloque default es opcional por lo tanto no es obligatorio que exista siempre un bloque default en una instrucción switch. Si el valor de la expresión no coincide con ningún case y no hay un bloque default, la ejecución continúa por la siguiente instrucción después de switch.

El bloque default suele escribirse de forma habitual al final del switch a continuación de todos los case pero no es obligatorio escribirlo al final, puede aparecer en cualquier lugar.
Los valores que aparecen en los case deben ser únicos. No puede haber dos etiquetas case con el mismo valor. En ese caso se produciría un error de compilación.
El valor que aparece en una etiqueta case no puede ser una variable. Debe ser un literal o una constante (una variable declarada como final).

La expresión de selección en un switch puede ser una variable o una expresión.

El tipo de la variable o de la expresión de selección debe ser uno de los siguientes:

• Tipo primitivo: byte, short, char, int.
• La clase envolvente de los tipos primitivos anteriores: Byte, Short, Character, Integer.
• Tipo String.
• Tipos enumerados (enum).

En su origen la instrucción switch no permitía que la variable o expresión fuera de un tipo diferente a los mostrados en la lista anterior. En particular, la instrucción switch original no permite los tipos long, boolean, float o double.

En las versiones recientes de Java se ha ampliado experimentalmente los tipos de datos que admite switch para incluir todos los tipos primitivos. Esta posibilidad se introdujo en Java 23 como característica preview y continúa como característica preview en JDK 27, por lo que para poder usarlos se requiere habilitar las características de vista previa.

Ejemplo 1:

Programa que lee por teclado un número de mes y muestra el nombre de mes correspondiente.

/*
 *  Ejemplo de estructura alternativa múltiple en Java (instrucción switch)
 *  Programa que lee una nota numérica y muestra su equivalente en texto
 */
import java.util.Scanner;
public class EjemploInstruccionSwitch1 {
   public static void main(String[] args) {
        int mes;
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduzca un numero de mes: ");
        mes = sc.nextInt(); //se introduce un número de mes y se guarda en la variable
        switch (mes) { //inicio de la instrucción switch
               case 1: System.out.println("ENERO");
                       break;
               case 2: System.out.println("FEBRERO");
                       break;
               case 3: System.out.println("MARZO");
                       break;
               case 4: System.out.println("ABRIL");
                       break;
               case 5: System.out.println("MAYO");
                       break;
               case 6: System.out.println("JUNIO");
                       break;
               case 7: System.out.println("JULIO");
                       break;
               case 8: System.out.println("AGOSTO");
                       break;
               case 9: System.out.println("SEPTIEMBRE");
                       break;
               case 10: System.out.println("OCTUBRE");
                        break;
               case 11: System.out.println("NOVIEMBRE");
                        break;
               case 12: System.out.println("DICIEMBRE");
                        break;
               default : System.out.println("Mes no válido");
        }//fin del switch
        System.out.println("Fin programa");
   }
}

En este ejemplo el valor introducido por teclado se guarda en la variable mes de tipo int.

Esta variable es la que se utiliza en en la instrucción switch para comprobar su valor.

Según el valor que contenga la variable mes se ejecutará el case que coincida con ese valor. Por ejemplo, si se ha introducido por teclado el valor 3, se ejecutará el código contenido en el case 3, en este caso, se ejecutará la instrucción:

System.out.println("MARZO");

A continuación de esta instrucción aparece la instrucción break; La instrucción break hace que la ejecución del programa continúe en la siguiente instrucción que haya después del switch. En este ejemplo, se ejecutará la instrucción:

System.out.println("Fin programa");

Si se introduce un número de mes que no coincide con ninguna etiqueta case se ejecutará el bloque default.

Dos ejemplos de ejecución del programa:

Introduzca un numero de mes: 3
MARZO
Fin programa

Introduzca un numero de mes: 0
Mes no válido
Fin programa

Ejemplo 2:

Programa que lee por teclado un String correspondiente al nombre de un mes y muestra el número de días que tiene ese mes.

/*
 *  Ejemplo de estructura alternativa múltiple en Java (instrucción switch)
 *  Programa que pide un nombre de mes y muestra el número de días correspondiente
 */
import java.util.Scanner;
public class EjemploInstruccionSwitch2 {
   public static void main(String[] args) {
        String mes;
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduzca un nombre de mes: ");
        mes = sc.nextLine();
        switch (mes.toUpperCase()) {
            case "ENERO":
                System.out.println("31 DÍAS");
                break;
            case "FEBRERO":
                System.out.println("28 ó 29 DÍAS");
                break;
            case "MARZO":
                System.out.println("31 DÍAS");
                break;
            case "ABRIL":
                System.out.println("30 DÍAS");
                break;
            case "MAYO":
                System.out.println("31 DÍAS");
                break;
            case "JUNIO":
                System.out.println("30 DÍAS");
                break;
            case "JULIO":
                System.out.println("31 DÍAS");
                break;
            case "AGOSTO":
                System.out.println("31 DÍAS");
                break;
            case "SEPTIEMBRE":
                System.out.println("30 DÍAS");
                break;
            case "OCTUBRE":
                System.out.println("31 DÍAS");
                break;
            case "NOVIEMBRE":
                System.out.println("30 DÍAS");
                break;
            case "DICIEMBRE":
                System.out.println("31 DÍAS");
                break;
            default:
                System.out.println("Mes no válido");
        }
        System.out.println("Fin programa");
   }
}

En este ejemplo el valor introducido por teclado se guarda en la variable mes de tipo String.

Esta variable es la que se utiliza en la instrucción switch para comprobar su valor.

En lugar de escribir la instrucción switch de esta forma:

switch(mes){

Se ha escrito así:

switch (mes.toUpperCase()) {

El método toUpperCase() toma el contenido del String mes y lo pasa a mayúsculas para que la instrucción switch realice la comprobación con el contenido de la variable en mayúsculas. El contenido original de la variable mes no cambia. Esto sirve para, por ejemplo, si se ha introducido por teclado “Enero” al pasarlo a mayúsculas coincidirá con el primer case. Si no lo pasamos a mayúsculas, “Enero” no coincide con ningún case y se ejecutará la instrucción default.

Dos ejemplos de ejecución del programa:

Introduzca un nombre de mes: Abril
30 DÍAS
Fin programa

Introduzca un nombre de mes: ENRO
Mes no válido
Fin programa

Ejemplo 3:

Switch con etiquetas case que contienen varias instrucciones.

En los ejemplos anteriores los case contenían una sola instrucción y el break, pero un case puede contener varias instrucciones que se ejecuten en secuencia. También pueden contener otro tipo de instrucciones como condiciones o bucles o incluso otro switch.

En el siguiente programa se muestra un ejemplo de switch en el que sus etiquetas case contienen en un caso varias instrucciones para ejecutar en secuencia, en otro caso una instrucción if y en otro caso una instrucción switch.

Programa Java que pide al usuario que introduzca un número de día del 1 al 5 (siendo 1 el lunes y 5 el viernes) y un número de mes del 1 al 12 (siendo 1 el mes de enero y 12 el mes de diciembre). El programa indicará a qué hora se imparte la clase de programación según el siguiente horario:

/*
 *  Ejemplo de estructura alternativa múltiple en Java (instrucción switch)
 *  Programa que pide un día y un mes y muestra a qué hora se imparte ese día la clase de programación
 */
import java.util.Scanner;
public class EjemploInstruccionSwitch3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int dia, mes;
        System.out.print("Introduce un número de día (1..5 1-> Lunes 5-> Viernes): ");
        dia = sc.nextInt();
        if (dia < 1 || dia > 5) {
            System.out.println("Día no válido");
        } else {
            System.out.print("Introduce un número de mes (1..12 1-> Enero 12-> Diciembre): ");
            mes = sc.nextInt();
            if (mes < 1 || mes > 12) {
                System.out.println("Mes no válido");
            } else {
                switch (dia) {
                    case 1:
                        System.out.println("Lunes");
                        System.out.println("Hay clase de programación de 09:00 a 11:00");
                        break;
                    case 3:
                        System.out.println("Miércoles");
                        if (mes >= 1 && mes <= 3) {
                            System.out.println("Hay clase de programación de 12:00 a 14:00");
                        } else {
                            System.out.println("Hay clase de programación de 10:00 a 12:00");
                        }
                        break;
                    case 4:
                        System.out.println("Jueves");
                        switch (mes) {
                            case 4:
                                System.out.println("Hay clase de programación de 08:00 a 10:00");
                                break;
                            case 6:
                                System.out.println("Hay clase de programación de 09:00 a 11:00");
                                break;
                            default:
                                System.out.println("Hay clase de programación de 18:00 a 20:00");
                                break;
                        }
                        break;
                    default:
                        System.out.println("No hay clase de programación");
                }
            }
        }
        System.out.println("Fin programa");
    }
}

En este programa se introduce un número de día del 1 al 5 y un número de mes del 1 al 12. Si el día o el mes introducidos no son válidos se muestra un mensaje indicándolo y el programa finaliza.

Si el día y el mes son válidos el programa funciona de la siguiente forma:

• Mediante una instrucción switch se comprueba el valor introducido para el día: switch (dia)
• Si el día introducido es 1 (lunes) se ejecuta el case 1 Los lunes se imparte siempre la clase de 9 a 11 sin depender del mes.
• Si el día introducido es 3 (miércoles) se ejecuta el case 3. Los miércoles el horario de la clase de programación depende del mes. Los meses de enero, febrero y marzo se imparte de 12 a 14 y el resto de meses de 10 a 12. El mes se comprueba mediante una instrucción if dentro del case.
• Si el día introducido es 4 (jueves) se ejecuta el case 4. Los jueves el horario de la clase de programación también depende del mes. En abril se imparte de 8 a 10, el junio de 9 a 11 y el resto de meses de 18 a 20. El mes se comprueba mediante una switch dentro del case. En este caso podemos hablar de un ejemplo de switch anidado, es decir, un switch dentro de otro switch.
• Si se ha introducido cualquier otro día se ejecuta la etiqueta default indicando que ese día no hay clase de programación.

Ejemplos de ejecución del programa:

Introduce un número de día (1..5 1-> Lunes 5-> Viernes): 3
Introduce un número de mes (1..12 1-> Enero 12-> Diciembre): 1
Miércoles
Hay clase de programación de 12:00 a 14:00
Fin programa

Introduce un número de día (1..5 1-> Lunes 5-> Viernes): 1
Introduce un número de mes (1..12 1-> Enero 12-> Diciembre): 12
Lunes
Hay clase de programación de 09:00 a 11:00
Fin programa

Introduce un número de día (1..5 1-> Lunes 5-> Viernes): 4
Introduce un número de mes (1..12 1-> Enero 12-> Diciembre): 7
Jueves
Hay clase de programación de 18:00 a 20:00
Fin programa

Introduce un número de día (1..5 1-> Lunes 5-> Viernes): 6
Día no válido
Fin programa

Introduce un número de día (1..5 1-> Lunes 5-> Viernes): 2
Introduce un número de mes (1..12 1-> Enero 12-> Diciembre): 14
Mes no válido
Fin programa

Ejemplo 4:

Uso de la instrucción break, agrupación de etiquetas case y el llamado fall-through.

En la sintaxis tradicional de switch en Java (en las instrucción switch), los bloques de instrucciones que aparecen en cada etiqueta case finalizan con la instrucción break.

Cuando la ejecución entra en uno de los bloques case, las instrucciones se ejecutan secuencialmente a partir de ese punto hasta encontrar un break.

La instrucción break no es obligatoria en cada case. Si la instrucción break no se escribe en un case, la ejecución continuará por las instrucciones de los siguientes case, aunque sus etiquetas no coincidan con el valor evaluado, hasta que se encuentre una instrucción break o hasta que se llegue al final del switch. Este comportamiento se conoce como fall-through, que puede traducirse como caída al siguiente caso.

Omitir la instrucción break en un case puede producir errores lógicos. Por ejemplo, si ejecutamos el siguiente fragmento de código:

int tipoArticulo = 3;
switch (tipoArticulo) {
        case 1:  System.out.println("Artículo con descuento del 10%");
        case 2:  System.out.println("Oferta 2 x 1");
        case 3:  System.out.println("Oferta 3 x 2");
        case 4:  System.out.println("Artículo a mitad de precio");
        default:  System.out.println("ERROR Artículo no válido");
}

Se muestra por pantalla:

Oferta 3 x 2
Artículo a mitad de precio
ERROR Artículo no válido

En el ejemplo, la variable tipoArticulo contiene el valor 3. Se ejecuta el case 3. Como no hay una instrucción break que finalice el case 3, la ejecución del programa continúa por las siguientes instrucciones del switch hasta encontrar un break o como en este caso hasta finalizar el switch.

Como se ve en este ejemplo, la ausencia de break puede producir errores de lógica, pero en otras ocasiones provocar un fall-through mediante la ausencia de la instrucción break puede ser útil para agrupar etiquetas case.

Cuando se tienen que ejecutar las mismas instrucciones para distintos valores de las etiquetas case, en lugar de repetir las instrucciones en cada case podemos agruparlas.

Ejemplo de agrupamiento de etiquetas case: Programa que pide introducir por teclado un número entero entre 1 y 7 correspondiente a un
día de la semana y muestra un mensaje indicando si ese día hay clase de programación o no:

Los días 1, 3, 5 se debe mostrar el mensaje «Tenemos clase de programación».

Los días 2 y 4 se debe mostrar los mensajes «Vaya, que pena» «Hoy no tenemos clase de programación»

Los días 6 y 7 se debe mostrar los mensajes «Fin de semana» «Estoy deseando que llegue el lunes!!»

/*
 *  Ejemplo de agrupación de etiquetas case 
 *  Programa que pide un número de día y muestra si hay o no clase de programación
 */
import java.util.Scanner;
public class EjemploInstruccionSwitch4 {
    public static void main(String[] args) {
        int numeroDia;
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduzca el numero del día de la semana (1 a 7): ");
        numeroDia = sc.nextInt();
        switch (numeroDia) {
            case 1:
            case 3:
            case 5: System.out.println("Tenemos clase de programación");
                    break;
            case 2:
            case 4: System.out.println("Vaya, que pena");
                    System.out.println("Hoy no tenemos clase de programación");
                    break;
            case 6:
            case 7: System.out.println("Fin de semana");
                    System.out.println("Estoy deseando que llegue el lunes!!");
                    break;
            default: System.out.println("Número de día no válido");
        }
        System.out.println("Fin programa");
    }
}

En este programa, para distintos valores de la etiqueta case se deben ejecutar las mismas instrucciones. En lugar de repetir la misma instrucción o instrucciones en cada case, se ha optado por agrupar las etiquetas case que deben ejecutar las mismas instrucciones, escribiéndolas una a continuación de otra. Por ejemplo para los días 1, 3 y 5 se han agrupado los tres case de forma que solo es necesario escribir las instrucciones System.out.println(«Tenemos clase de programación»); y break; a continuación del case 5.

Si se introduce por ejemplo un 1 en número de día, la ejecución pasará al case 1 y como no hay break se producirá un fall-through ejecutando las instrucciones que encuentre desde ese punto hacia abajo hasta encontrar un break. En este caso se ejecutará la instrucción System.out.println(«Tenemos clase de programación»); y se alcanza el break.

Cuando la ejecución del programa entra en uno de los case, el programa sigue ejecutándose desde ese punto hasta que encuentre el primer break (estén dentro del mismo case o no) o hasta que se llegue al final del switch en cuyo caso continuará por la instrucción que se encuentre a continuación del switch.

A partir de Java 14 el agrupamiento de etiquetas case se puede realizar escribiendo todos los valores de las etiquetas que queremos agrupar separados por comas. De esta forma nos evitamos tener que repetir la palabra case.

El ejemplo anterior también lo podemos escribir agrupando las etiquetas case de esta forma:

/*
 *  Ejemplo de agrupación de etiquetas case 
 *  Programa que pide un número de día y muestra si hay o no clase de programación
 *  Agrupando las etiquetas case en una sola, escribiendo los valores separados por comas
 */
import java.util.Scanner;
public class EjemploInstruccionSwitch4 {
    public static void main(String[] args) {
        int numeroDia;
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduzca el numero del día de la semana (1 a 7): ");
        numeroDia = sc.nextInt();
        switch (numeroDia) {
            case 1, 3, 5: System.out.println("Tenemos clase de programación");
                          break;
            case 2, 4: System.out.println("Vaya, que pena");
                       System.out.println("Hoy no tenemos clase de programación");
                       break;
            case 6, 7: System.out.println("Fin de semana");
                       System.out.println("Estoy deseando que llegue el lunes!!");
                       break;
            default: System.out.println("Número de día no válido");
        }
        System.out.println("Fin programa");
    }
}

Como se ha comentado anteriormente, las expresiones switch son el resultado de la evolución de las instrucciones switch a través de las diferentes versiones del JDK.

Las continuas incorporaciones de mejoras y funcionalidades en la instrucción switch ha dado lugar a la aparición de las expresiones switch de forma que ahora podemos usar ambos tipos de switch en nuestros programas.

Las dos formas de switch (instrucción switch y expresión switch) sirven para controlar el flujo de ejecución del programa seleccionando las instrucciones a ejecutar en función del valor de una expresión. La diferencia entre ambas, además de la sintaxis, es que una expresión switch puede devolver un valor como resultado.

La sintaxis de las expresiones switch es similar a la de la instrucción switch tradicional, pero presenta algunas diferencias entre ellas:

• El uso de la flecha -> en las etiquetas case
• No hay que escribir la instrucción break
• El uso de la palabra yield para devolver un valor
• El uso de llaves { } en los case que contengan más de una instrucción
• Si se devuelve un valor hay que escribir el carácter ; después de la llave de finalización del switch

El funcionamiento de las expresiones switch es similar al explicado para las instrucciones switch.

El flujo de ejecución lo determina el valor de una variable o expresión. La ejecución del programa salta a la etiqueta case que coincida con el valor de la expresión.

Pero hay una diferencia importante respecto a las instrucciones switch: en las expresiones switch no es necesario indicar el final de un case mediante la instrucción break. Cuando un case finaliza, la ejecución del programa continúa por la siguiente instrucción a continuación del switch.

Además, las expresiones switch pueden devolver un valor por lo que el funcionamiento en ese caso también es diferente al switch tradicional.

Importante: Cuando switch devuelve un valor, la expresión switch debe ser exhaustiva. Esto quiere decir que en los case se deben cubrir todos los valores posibles que puede tomar la variable que se le envía al switch. Si en los case no se cubren todos los valores que puede tomar la variable, será obligatorio incluir un default. Si no se incluye obtendremos el error de compilación the switch expression does not cover all possible input values.

Explicamos el funcionamiento de las expresiones switch con distintos ejemplos.

Ejemplo 1:

Programa que pida que se introduzca por teclado un número del 1 al 7 correspondiente a un número de día y muestre el nombre del día. Por ejemplo, si se introduce el número 1, se mostrará “Lunes”.

/*
 *  Ejemplo de expresión switch 
 *  Programa que pide un número de día del 1 al 7 y muestra el nombre del día
 */
import java.util.Scanner;
public class EjemploExpresionSwitch1 {
    public static void main(String[] args) {
        int dia;
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduce un número del 1 al 7: ");
        dia = sc.nextInt();
        switch (dia) {
            case 1 -> System.out.println("Lunes");
            case 2 -> System.out.println("Martes");
            case 3 -> System.out.println("Miércoles");
            case 4 -> System.out.println("Jueves");
            case 5 -> System.out.println("Viernes");
            case 6 -> System.out.println("Sábado");
            case 7 -> System.out.println("Domingo");
            default -> System.out.println("Valor no válido");
        }
        System.out.println("Fin programa");
    }
}

En este primer ejemplo podemos ver que en la expresión switch se sustituyen los : después del case por una flecha ->

Como ocurre con el switch tradicional, primero se evalúa una variable o expresión. En este caso se evalúa el valor de la variable dia.

La ejecución salta al case cuyo valor coincida con el valor de la variable. Si no coincide con ningún case saltará a la etiqueta default.

A la derecha de la flecha en cada case se escribe la instrucción o instrucciones que se deben ejecutar. En este ejemplo solo se ejecuta una instrucción en los case. Si hubiese más de una instrucción se deben escribir entre llaves { }

La instrucción break desaparece en las expresiones switch. Cuando finaliza la ejecución de las instrucciones del case, el programa continúa por la siguiente instrucción que se encuentre a continuación del switch.

En este ejemplo el switch no devuelve ningún valor por lo que la etiqueta default es opcional.

Ejemplo de ejecución:

Introduce un número del 1 al 7: 4
Jueves
Fin programa

Ejemplo 2:

Ejemplo de expresión switch que devuelve un valor.

En el ejemplo anterior en cada case se muestra por pantalla el mensaje correspondiente al nombre del día introducido. Como la expresión switch puede devolver un valor, podemos escribir otra versión del programa de forma que el switch nos devuelva el String que tenemos que mostrar por pantalla.

/*
 *  Ejemplo de expresión switch que devuelve un valor
 *  Programa que pide un número de día del 1 al 7 y muestra el nombre del día
 *  El switch devolverá el String con el nombre del día
 */
import java.util.Scanner;
public class EjemploExpresionSwitch2 {
    public static void main(String[] args) {
        int dia;
        String nombreDia;
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduce un número del 1 al 7: ");
        dia = sc.nextInt();
        nombreDia = switch (dia) { //el valor devuelto se almacena en la variable nombreDia
            case 1 -> "Lunes";
            case 2 -> "Martes";
            case 3 -> "Miércoles";
            case 4 -> "Jueves";
            case 5 -> "Viernes";
            case 6 -> "Sábado";
            case 7 -> "Domingo";
            default -> "Valor no válido";
        };
        System.out.println(nombreDia);
        System.out.println("Fin programa");
    }
}

El switch devuelve el String y después se muestra por pantalla.

El funcionamiento es este:

Importante: En este ejemplo la etiqueta default es obligatoria ya que los case no cubren todos los posibles valores que puede tomar la variable dia. Los valores que puede tomar una variable entera son muchos más que los valores del 1 al 7 que aparecen en los case. Como la expresión switch debe devolver algo para asignárselo a la variable nombreDia, si introducimos un valor que no coincide con ningún case podrá devolver lo que contenga default.

Importante: Como la expresión switch devuelve un valor que se le asigna a una variable, estamos realizando una instrucción de asignación y debe finalizar con un ; después de la llave que cierra el switch. Si por ejemplo día = 3, el resultado de este switch es esta asignación:

nombreDia = "Miércoles";

y como cualquier instrucción de este tipo debe finalizar con ;

Ejemplo 3:

Agrupar etiquetas case y uso de llaves.

En las expresiones switch también se pueden agrupar las etiquetas case. Para agruparlas se hace igual que en la instrucción switch tradicional, separando los valores por comas.

En este programa veremos un ejemplo de agrupamiento de etiquetas case y el uso de llaves cuando el case contiene varias instrucciones que se deben ejecutar. Se trata del mismo programa realizado en el Ejemplo 4 de instrucciones switch pero en este caso realizado con una expresión switch.

/*
 *  Ejemplo de expresión switch con agrupamiento de etiquetas case
 *  Programa que pide un número de día y muestra si hay o no clase de programación
 */
import java.util.Scanner;
public class EjemploExpresionSwitch3 {
    public static void main(String[] args) {
       int numeroDia;
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduzca el número del día de la semana (1 a 7): ");
        numeroDia = sc.nextInt();
        switch (numeroDia) {
            case 1, 3, 5 -> System.out.println("Tenemos clase de programación");
            case 2, 4 -> {
                          System.out.println("Vaya, que pena");
                          System.out.println("Hoy no tenemos clase de programación");
                         }
            case 6, 7 -> {
                          System.out.println("Fin de semana");
                          System.out.println("Estoy deseando que llegue el lunes!!");
                         }
            default -> System.out.println("Número de día no válido");
        }
        System.out.println("Fin programa");
    }
}

Las etiquetas case que realizan las mismas instrucciones se agrupan separando sus valores por comas y escribiendo la flecha -> a continuación.

En las etiquetas case que contienen varias instrucciones, las instrucciones a ejecutar se deben escribir entre llaves.

Ejemplo 4:

Uso de yield para devolver un valor.

Cuando un switch devuelve un valor y el case contiene varias instrucciones, la palabra yield indica el valor que se devuelve.

En los ejemplos anteriores en los que switch ha devuelto un valor no ha sido necesario el uso de yield ya que en los case solo aparecía una única instrucción que era el valor a devolver. Veremos ahora un ejemplo en el que es necesario el uso de yield.

Programa que calcula el precio final de un producto. Se pide al usuario que introduzca el precio del producto y el tipo de cliente (1 cliente estándar, 2 cliente premium, 3 cliente VIP) y calculará el precio final de la siguiente forma:

Cliente estándar: Se pide por teclado los gastos de envío. El precio final es el precio del producto más los gastos de envío.

Cliente premium: Se pide por teclado el porcentaje de descuento. El precio final es el precio del producto menos el descuento.

Cliente VIP: El precio final es el precio del producto menos el 20% de descuento.

/*
 *  Ejemplo de expresión switch que devuelve un valor mediante yield
 *  Calcular y mostrar el precio final de un producto según el tipo de cliente
 */
import java.util.Scanner;
public class EjemploExpresionSwitch4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double precio, descuento, gastosEnvio, precioFinal;
        int tipoCliente;
        System.out.print("Introduzca precio del producto: ");
        precio = sc.nextDouble();
        System.out.print("Introduzca tipo de cliente (1-> Estándar 2-> Premium 3-> VIP): ");
        tipoCliente = sc.nextInt();
        precioFinal = switch (tipoCliente) {
            case 1 -> {
                //cliente estándar
                System.out.print("Introduce gastos de envío: ");
                gastosEnvio = sc.nextDouble();
                yield precio + gastosEnvio;
            }
            case 2 -> {
                //cliente premium
                System.out.print("Introduce % descuento: ");
                descuento = sc.nextDouble();
                yield precio - precio * descuento / 100;
            }
            case 3 -> {
                //cliente VIP
                descuento = precio * 0.20;
                yield precio - descuento;
            }
            default -> {
                System.out.println("Tipo clienteo no válido");
                yield precio;
            }
        };
        System.out.println("Precio final: " + precioFinal + "€");
        System.out.println("Fin programa");
    }
}

Dentro de los case se ejecutan varias instrucciones. Al final de ellas mediante yield se devuelve un valor. Este valor devuelto por el switch se le asigna a la variable precioFinal.

En estos ejemplos henos visto algunas de las características que incorporan las expresiones switch. Hay otras características más avanzadas como el pattern matching de las que puedes encontrar documentación en:

https://docs.oracle.com/en/java/javase/26/language/pattern-matching-switch.html

https://www.baeldung.com/java-switch-pattern-matching

El operador condicional se considera como una estructura de control condicional en Java ya que permite decidir qué instrucciones se ejecutan según el valor de una condición.

En instrucciones sencillas el operador condicional se puede utilizar en sustitución de la instrucción if .. else.

El operador condicional en java consiste en dos caracteres ? y :

Al operador condicional también se le conoce como operador ternario porque necesita tres operandos: una condición, el valor que se devuelve si la condición es cierta y el valor que se devuelve si la condición es falsa.

Sintaxis:

condición ? expresión1 : expresión2

Se evalúa la condición y si es cierta se devuelve expresión1. Si es falsa se devuelve expresión2.

La condición se escribe antes del carácter ?

Entre el carácter ? y el carácter : se escribe la expresión que se devuelve si la condición es cierta.

A partir del carácter : se escribe la expresión que se devuelve si la condición es falsa.

Programa que pide por teclado un número entero y muestra si es par o impar.

import java.util.Scanner;
public class EjemploOperadorCondicional {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num;
        System.out.print("Introduzca número: ");
        num = sc.nextInt();
        System.out.println(num % 2 == 0 ? "PAR" : "IMPAR");
    }
}

Para comprobar si el número es par o impar se ha usado el operador condicional:

num % 2 == 0 ? "PAR" : "IMPAR"

num % 2 == 0 es la condición

Si la condición es cierta el operador condicional devuelve el String «PAR»

Si la condición es falsa devuelve «IMPAR».

El operador condicional está dentro de una instrucción System.out.println. El String que devuelve el operador lo recibe esta instrucción y lo muestra por pantalla.

Ejemplo de ejecución:

Introduzca número: 4
PAR

El operador condicional en Java se explica ampliamente en el tema Operador ternario en Java con varios ejemplos de uso que incluyen casos de operadores condicionales anidados.

La estructura condicional en Java es una de las tres que componen las estructuras de control en Java.

En estos temas se explican a fondo la estructura secuencial y repetitiva:

Documentación oficial de Oracle sobre las estructuras de control en Java:

https://docs.oracle.com/javase/tutorial/java/nutsandbolts/flow.html