En el desarrollo de aplicaciones Java, la ejecución de sentencias no siempre sigue un camino lineal. Para manejar diferentes escenarios y tomar decisiones, se utilizan estructuras de control de flujo. Principalmente, distinguimos tres categorías:

• Estructura Secuencial: Las instrucciones se ejecutan una tras otra en el orden en que aparecen.
• Estructura Condicional (o de Selección/Bifurcación): Permite que el programa elija qué bloque de código ejecutar basándose en una condición.
• Estructura Repetitiva (o de Bucle/Iteración): Permite ejecutar un bloque de código múltiples veces.

A continuación, exploraremos en detalle las estructuras secuencial y condicional en Java.

1. Ejecución Secuencial

La estructura secuencial es el flujo de ejecución predeterminado en Java. Significa que las sentencias se procesan en el orden en que están escritas, de arriba hacia abajo, una después de la otra. Cada instrucción se completa antes de que comience la siguiente.

public class FlujoSecuencial {
   public static void main(String[] args) {
       System.out.println("Primera instrucción");
       System.out.println("Segunda instrucción");
       System.out.println("Tercera instrucción");
   }
}
// Salida en consola:
// Primera instrucción
// Segunda instrucción
// Tercera instrucción

Si alteramos el orden de las sentencias, el flujo de ejecución se ajustará consecuentemente:

public class FlujoOrdenado {
   public static void main(String[] args) {
       System.out.println("Instrucción B");
       System.out.println("Instrucción A");
       System.out.println("Instrucción C");
   }
}
// Salida en consola:
// Instrucción B
// Instrucción A
// Instrucción C

2. Estructuras Condicionales (Bifurcación)

Las estructuras condicionales permiten al programa tomar decisiones y ejecutar diferentes bloques de código según si una condición booleana es verdadera o falsa. Las más comunes en Java son las sentencias if y switch.

2.1. Sentencia if

La sentencia if es la base para la toma de decsiiones. Permite ejecutar un bloque de código solo si una expresión booleana es verdadera.

a) if simple (una única rama)

Este formato evalúa una expresión. Si el resultado es true, se ejecuta el bloque de código dentro de las llaves. Si es false, el bloque se omite.

if (expresionBooleana) {
   // Código a ejecutar si la expresión es verdadera
}

Ejemplo:

int numero = 15;
if (numero > 10) {
   System.out.println("El número " + numero + " es mayor que 10.");
}

b) if-else (doble rama)

Cuando se requiere ejecutar un bloque de código si la condición es verdadera y otro si es falsa, se utiliza if-else.

if (expresionBooleana) {
   // Código a ejecutar si la expresión es verdadera
} else {
   // Código a ejecutar si la expresión es falsa
}

Ejemplo:

int valor = 7;
if (valor % 2 == 0) {
   System.out.println(valor + " es un número par.");
} else {
   System.out.println(valor + " es un número impar.");
}

c) if-else if-else (múltiples ramas)

Para manejar múltiples condiciones mutuamente excluyentes, se encadenan sentencias else if. El primer if o else if cuya condición sea verdadera ejecuta su bloque de código y las demás conidciones se ignoran. El bloque else final se ejecuta si ninguna de las condiciones anteriores fue verdadera.

if (expresionBooleana1) {
   // Código si la expresión 1 es verdadera
} else if (expresionBooleana2) {
   // Código si la expresión 2 es verdadera
} else if (expresionBooleana3) {
   // Código si la expresión 3 es verdadera
} else {
   // Código si ninguna de las expresiones anteriores fue verdadera
}

Ejemplo: Clasificación de una calificación numérica:

• 90-100: Excelente
• 80-89: Notable
• 70-79: Bueno
• 60-69: Suficiente
• 0-59: Insuficiente
• Cualquier otro: Calificación no válida

int calificacion = 85;
if (calificacion >= 90 && calificacion <= 100) {
   System.out.println("Calificación: Excelente");
} else if (calificacion >= 80) {
   System.out.println("Calificación: Notable");
} else if (calificacion >= 70) {
   System.out.println("Calificación: Bueno");
} else if (calificacion >= 60) {
   System.out.println("Calificación: Suficiente");
} else if (calificacion >= 0 && calificacion < 60) {
   System.out.println("Calificación: Insuficiente");
} else {
   System.out.println("Calificación no válida");
}

Consideraciones para las sentencias if:

• Es una buena práctica colocar la llave de apertura { en la misma línea que la sentencia if o else.
• Nunca se coloca un punto y coma ; inmediatamente después de un if (...) o else.
• Si un bloque if o else contiene una única sentencia, las llaves son opcionales. Sin embargo, se recomienda usarlas siempre para mejorar la legibilidad y evitar errores lógicos, especialmente al añadir más sentencias posteriormente.
• En el caso de if aniaddos sin llaves, un else siempre se asocia con el if más cercano no emparejado.

2.2. Sentencia switch

La sentencia switch ofrece una alternativa a la secuencia if-else if-else cuando se necesita tomar decisiones basadas en el valor exacto de una única variable o expresión. Es ideal para situaciones con múltiples opciones predefinidas.

Sintaxis:

switch (expresion) {
   case valorConstante1:
       // Código a ejecutar si la expresión coincide con valorConstante1
       break; // Opcional, pero muy recomendado
   case valorConstante2:
       // Código a ejecutar si la expresión coincide con valorConstante2
       break;
   // ... más casos ...
   default:
       // Código a ejecutar si la expresión no coincide con ningún caso
       break; // Opcional para el default si es la última sentencia
}

Pasos de ejecución:

1. Se evalúa la expresion dentro de los paréntesis del switch.
2. El resultado se compara secuencialmente con los valorConstante de cada case.
3. Si se encuentra una coincidencia, se ejecuta el bloque de código asociado a ese case.
4. La ejecución continúa hasta encontrar una sentencia break, que finaliza el switch.
5. Si la expresion no coincide con ningún case, se ejecuta el bloque default (si está presente).

Ejemplo: Determinar el día de la semana:

int diaNumero = 3;
String nombreDia;

switch (diaNumero) {
   case 1:
       nombreDia = "Lunes";
       break;
   case 2:
       nombreDia = "Martes";
       break;
   case 3:
       nombreDia = "Miércoles";
       break;
   case 4:
       nombreDia = "Jueves";
       break;
   case 5:
       nombreDia = "Viernes";
       break;
   case 6:
       nombreDia = "Sábado";
       break;
   case 7:
       nombreDia = "Domingo";
       break;
   default:
       nombreDia = "Día inválido";
       break;
}
System.out.println("Hoy es: " + nombreDia); // Salida: Hoy es: Miércoles

Puntos importantes sobre switch:

• Los valores de los case deben ser constantes literales o finales y no pueden repetirse.
• La expresión del switch solo puede ser de los siguientes tipos de datos: byte, short, char, int, String, o tipos enum. No se permite long, float, double, ni boolean directamente.
• La sentencia break es crucial. Si se omite, la ejecución "cae" al siguiente case, ejecutando el código de ese caso también (conocido como "fall-through") hasta encontrar un break o el final del switch.
• Aunque Java permite anidar sentencias switch, generalmente no se recomienda debido a que puede reducir la legibilidad y la mantenibilidad del código.