El flujo de ejecución en los programas Java se gestiona mediante estructuras que determinan el orden de las instrucciones. Estas estructuras permiten que el código reaccione a condiciones y repita acciones según sea necesario.

Control secuencial

La ejecución se realiza de forma lineal, instrucción por instrucción, sin desviaciones ni decisiones intermedias.

Estructuras de bifurcación

Permiten al programa elegir entre diferentes caminos de ejecución basados en condiciones evaluadas.

Bifuracción simple

if (condicion) {
    // Acciones a realizar si la condición es verdadera
}

Bifurcación doble

if (condicion) {
    // Bloque ejecutado cuando la condición se cumple
} else {
    // Bloque ejecutado en caso contrario
}

La cláusula else se asocia siempre a la bifurcación if más cercana sin else asignado.

Bifurcación múltiple

if (condicion1) {
    // Acciones para la primera condición
} else if (condicion2) {
    // Acciones para la segunda condición
} else if (condicion3) {
    // Acciones para la tercera condición
} else {
    // Acciones por defecto si ninguna condición anterior se cumple
}

El bloque final puede omitirse si se prefiere que solo se ejecuten los casos específicos.

Bifurcaciones anidadas

if (condicionExterna) {
    if (condicionInterna) {
        // Código interno cuando ambas condiciones son verdaderas
    } else {
        // Código interno para el caso alternativo
    }
} else {
    // Acciones cuando la condición externa es falsa
}

Estructura switch

switch (expresion) {
    case valor1:
        // Instrucciones para el primer caso
        break;
    case valor2:
        // Instrucciones para el segundo caso
        break;
    default:
        // Instrucciones ejecutadas si ningún caso coincide
        break;
}

La expresión evaluada debe devolver un tipo byte, short, int, char, enum o String.

Estructuras de bucle

Permiten ejecutar un bloque de código repetidamente hasta que se cumpla una condición de terminación.

Bucle for

for (inicializacion; condicion; actualizacion) {
    // Cuerpo del bucle
}

Las variables declaradas dentro del encabezado for solo son acesibles dentro del bucle. Se pueden usar nombres idénticos en bucles for independientes.

Bucle while

while (condicion) {
    // Acciones repetitivas
    actualizacionVariable;
}

Bucle do-while

inicializacionVariable;
do {
    // Acciones a repetir
    actualizacionVariable;
} while (condicion);

Este bucle garantiza al menos una ejecución del bloque antes de verificar la condición.

Bucles anidados

La inclusión de un bucle dentro de otro permite procesar estructuras de datos complejas o patrones repetitivos.

Tabla de multiplicar

public class TablaMultiplicacion {
    public static void main(String[] args) {
        for (int fila = 1; fila <= 9; fila++) {
            for (int columna = 1; columna <= fila; columna++) {
                System.out.print(columna + "*" + fila + "=" + (columna * fila) + "\t");
            }
            System.out.println();
        }
    }
}

Pirámide hueca

public class PiramideHueca {
    public static void main(String[] args) {
        int niveles = 10;
        for (int nivelActual = 1; nivelActual <= niveles; nivelActual++) {
            for (int espacio = 1; espacio <= niveles - nivelActual; espacio++) {
                System.out.print(" ");
            }
            for (int asterisco = 1; asterisco <= 2 * nivelActual - 1; asterisco++) {
                if (asterisco == 1 || asterisco == 2 * nivelActual - 1 || nivelActual == niveles) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}

Sentencias de salto

Modifican el flujo normal de los bucles o métodos, permitiendo salir de estructuras de control anticipadamente.

Sentencia break

etiqueta1: {
    etiqueta2: {
        etiqueta3: {
            break etiqueta1; // Sale del bloque etiquetado
            // Otras instrucciones
        }
    }
}

Se puede usar con etiquetas para salir de bucles anidados múltiples.

Sentencia continue

for (...) {
    if (condicion) {
        continue; // Salta a la siguiente iteración del bucle
    }
    // Resto del cuerpo del bucle
}

Interrumpe la iteración actual del bucle y prosigue con la siguiente.

Sentencia return

Finaliza la ejecución del método actual y puede devolver un valor al invocador. Se utiliza para controlar el flujo de salida de una función.