Sintaxis de Java: Control de Flujo

// En C esto es válido (pero peligroso):
// if (x = 5) { ... }  // Asigna 5 a x, evalúa como verdadero

// En Java esto NO compila (error de tipos):
int x = 5;
// if (x) { }        // Error: incompatible types: int cannot be converted to boolean
if (x != 0) { }      // Correcto: expresión booleana explícita

boolean esMayor = true;
boolean tieneDNI = false;

// AND: ambas condiciones deben ser verdaderas
boolean puedeVotar = esMayor && tieneDNI;  // false

// OR: al menos una condición debe ser verdadera
boolean puedeEntrar = esMayor || tieneDNI;  // true

// NOT: invierte el valor
boolean esmenor = !esMayor;  // false

int x = 0;
boolean resultado1 = (false && (++x > 0));  // x sigue siendo 0
boolean resultado2 = (false & (++x > 0));   // x ahora es 1 (se evaluó ++x)

if (condicion) {
    // código que se ejecuta si condicion es true
}
// La ejecución continúa aquí, independientemente de la condición

int temperatura = 35;

if (temperatura > 30) {
    System.out.println("Hace calor");
}
// Si temperatura es 25, no se imprime nada y el programa continúa

if (condicion) {
    // código si condicion es true (rama verdadera)
} else {
    // código si condicion es false (rama falsa)
}

int edad = 17;

if (edad >= 18) {
    System.out.println("Es mayor de edad");
} else {
    System.out.println("Es menor de edad");
}
// Siempre se imprime exactamente uno de los dos mensajes

if (condicion1) {
    // código si condicion1 es true
} else if (condicion2) {
    // código si condicion1 es false y condicion2 es true
} else if (condicion3) {
    // código si condicion1 y condicion2 son false y condicion3 es true
} else {
    // código si ninguna condición anterior es true (opcional pero recomendado)
}

int nota = 75;
String clasificacion;

if (nota >= 90) {
    clasificacion = "Sobresaliente";
} else if (nota >= 80) {
    clasificacion = "Muy bueno";
} else if (nota >= 70) {
    clasificacion = "Bueno";
} else if (nota >= 60) {
    clasificacion = "Regular";
} else {
    clasificacion = "Insuficiente";
}
// Si nota es 75, solo se ejecuta clasificacion = "Bueno"
// Las condiciones >= 60 nunca se evalúan porque ya se encontró una verdadera

int edad = 25;
boolean tieneLicencia = true;

if (edad >= 18) {
    System.out.println("Es mayor de edad");
    if (tieneLicencia) {
        System.out.println("Puede conducir");
    } else {
        System.out.println("Necesita obtener licencia");
    }
} else {
    System.out.println("Es menor de edad, no puede conducir");
}

resultado = condicion ? valorSiTrue : valorSiFalse;

int edad = 20;
String estado = (edad >= 18) ? "Mayor" : "Menor";

// Equivale a:
String estado2;
if (edad >= 18) {
    estado2 = "Mayor";
} else {
    estado2 = "Menor";
}

// En una asignación
int maximo = (a > b) ? a : b;

// En una llamada a método
System.out.println("El valor es " + ((x > 0) ? "positivo" : "no positivo"));

// En un return
return (lista.isEmpty()) ? valorPorDefecto : lista.get(0);

switch (expresion) {
    case valor1:
        // código para valor1
        break;
    case valor2:
        // código para valor2
        break;
    case valor3:
    case valor4:
        // código para valor3 O valor4 (casos agrupados)
        break;
    default:
        // código si ningún caso coincide
        break;
}

int diaSemana = 3;
String nombreDia;

switch (diaSemana) {
    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:
    case 7:
        nombreDia = "Fin de semana";  // Casos 6 y 7 comparten el mismo código
        break;
    default:
        nombreDia = "Día inválido";
        break;
}

String comando = "salir";

switch (comando) {
    case "iniciar":
        System.out.println("Iniciando...");
        break;
    case "pausar":
        System.out.println("Pausando...");
        break;
    case "salir":
        System.out.println("Saliendo...");
        break;
    default:
        System.out.println("Comando no reconocido");
        break;
}

int diaSemana = 3;
String nombreDia = switch (diaSemana) {
    case 1 -> "Lunes";
    case 2 -> "Martes";
    case 3 -> "Miércoles";
    case 4 -> "Jueves";
    case 5 -> "Viernes";
    case 6, 7 -> "Fin de semana";  // Múltiples valores en un caso
    default -> "Día inválido";
};  // Nota el punto y coma: es una expresión que termina en asignación

String descripcion = switch (estado) {
    case ACTIVO -> "Sistema funcionando";
    case PENDIENTE -> {
        System.out.println("Procesando pendiente...");
        yield "Esperando confirmación";  // yield retorna el valor del bloque
    }
    case ERROR -> {
        registrarError();
        notificarAdministrador();
        yield "Sistema en error";
    }
    default -> "Estado desconocido";
};

for (inicializacion; condicion; actualizacion) {
    // código que se repite mientras condicion sea true
}

for (int i = 1; i <= 5; i = i + 1) {
    System.out.println(i);
}
// Imprime: 1, 2, 3, 4, 5

// Traza de ejecución:
// i=1: condición 1<=5 es true, imprime 1, actualiza i=2
// i=2: condición 2<=5 es true, imprime 2, actualiza i=3
// i=3: condición 3<=5 es true, imprime 3, actualiza i=4
// i=4: condición 4<=5 es true, imprime 4, actualiza i=5
// i=5: condición 5<=5 es true, imprime 5, actualiza i=6
// i=6: condición 6<=5 es false, termina el lazo

for (int i = 10; i >= 0; i = i - 1) {
    System.out.println(i);
}
// Imprime: 10, 9, 8, ..., 1, 0

// Imprimir números pares del 0 al 20
for (int i = 0; i <= 20; i = i + 2) {
    System.out.println(i);
}
// Imprime: 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20

// Variable ya inicializada afuera
int i = 0;
for (; i < 10; i = i + 1) {
    System.out.println(i);
}

// Actualización dentro del cuerpo
for (int j = 0; j < 10; ) {
    System.out.println(j);
    j = j + 1;
}

// Lazo infinito (usar con cuidado)
// for (;;) {
//     // Se ejecuta indefinidamente
// }

while (condicion) {
    // código que se repite mientras condicion sea true
}

int suma = 0;
int numero = 1;

while (suma < 100) {
    suma = suma + numero;
    numero = numero + 1;
}

System.out.println("Suma final: " + suma);
System.out.println("Último número sumado: " + (numero - 1));

// Traza: suma=0, agrega 1 (suma=1), agrega 2 (suma=3), agrega 3 (suma=6)...
// Continúa hasta que suma >= 100

int x = 10;

while (x < 5) {  // Condición es false desde el inicio
    System.out.println(x);  // Nunca se ejecuta
    x = x + 1;
}

System.out.println("Lazo terminado");  // Se imprime directamente

boolean encontrado = false;  // Bandera: indica si encontramos el valor
int indice = 0;

// El lazo continúa mientras no hayamos encontrado Y queden elementos
while (indice < cantidad && !encontrado) {
    if (elementos[indice] == valorBuscado) {
        encontrado = true;  // Encontramos el valor, el lazo terminará
        // NO incrementamos indice para conservar la posición encontrada
    } else {
        indice = indice + 1;  // Avanzar solo si no encontramos
    }
}

// Después del lazo, verificamos qué pasó
if (encontrado) {
    System.out.println("Encontrado en posición: " + indice);
} else {
    System.out.println("No encontrado");
}

do {
    // código que se ejecuta al menos una vez
} while (condicion);  // Nota: termina con punto y coma

int opcion;
do {
    System.out.println("Menú:");
    System.out.println("1. Opción A");
    System.out.println("2. Opción B");
    System.out.println("0. Salir");
    System.out.print("Seleccione: ");
    opcion = scanner.nextInt();
} while (opcion != 0);

// El menú se muestra al menos una vez antes de verificar si el usuario quiere salir

int numero;
do {
    System.out.print("Ingrese un número entre 1 y 10: ");
    numero = scanner.nextInt();
    
    if (numero < 1 || numero > 10) {
        System.out.println("Valor fuera de rango. Intente nuevamente.");
    }
} while (numero < 1 || numero > 10);

System.out.println("Número válido ingresado: " + numero);

int x = 100;

// Con while: no se ejecuta ninguna vez
while (x < 10) {
    System.out.println("while: " + x);
    x = x + 1;
}

// Con do-while: se ejecuta exactamente una vez
do {
    System.out.println("do-while: " + x);  // Imprime "do-while: 100"
    x = x + 1;
} while (x < 10);

// FOR: cuando conocés la cantidad de iteraciones
// "Hacer algo N veces" o "recorrer de A a B"
for (int i = 0; i < 10; i = i + 1) {
    // Exactamente 10 iteraciones (0 a 9)
}

// WHILE: cuando no sabés cuántas iteraciones, pero podría ser cero
// "Mientras haya datos" o "hasta que se cumpla X"
while (hayMasDatos()) {
    procesarSiguiente();
}

// DO-WHILE: cuando necesitás al menos una iteración
// "Hacer al menos una vez, repetir si es necesario"
do {
    pedirDato();
} while (!datoValido());

for (int i = 0; i < 10; i = i + 1) {
    System.out.println(i);
}

int i = 0;                    // Inicialización (antes del lazo)
while (i < 10) {              // Condición
    System.out.println(i);
    i = i + 1;                // Actualización (al final del cuerpo)
}

for (int fila = 1; fila <= 5; fila = fila + 1) {
    for (int columna = 1; columna <= 5; columna = columna + 1) {
        int producto = fila * columna;
        System.out.print(producto + "\t");  // \t es tabulador
    }
    System.out.println();  // Nueva línea después de cada fila
}

// Salida:
// 1    2    3    4    5
// 2    4    6    8    10
// 3    6    9    12   15
// 4    8    12   16   20
// 5    10   15   20   25

for (int i = 1; i <= 3; i = i + 1) {
    System.out.println("Lazo externo: i = " + i);
    for (int j = 1; j <= 2; j = j + 1) {
        System.out.println("  Lazo interno: j = " + j);
    }
}

// Salida:
// Lazo externo: i = 1
//   Lazo interno: j = 1
//   Lazo interno: j = 2
// Lazo externo: i = 2
//   Lazo interno: j = 1
//   Lazo interno: j = 2
// Lazo externo: i = 3
//   Lazo interno: j = 1
//   Lazo interno: j = 2

// Error 1: Condición siempre verdadera
while (true) {
    System.out.println("Infinito!");
}

// Error 2: Variable de control no modificada
int i = 0;
while (i < 10) {
    System.out.println(i);
    // Falta: i = i + 1;
}

// Error 3: Actualización en dirección incorrecta
for (int j = 0; j < 10; j = j - 1) {  // j decrece, nunca llega a 10
    System.out.println(j);
}

// Error 4: Condición que no puede volverse falsa
int k = 1;
while (k != 10) {  // k solo toma valores impares
    System.out.println(k);
    k = k + 2;  // k: 1, 3, 5, 7, 9, 11, 13, ... nunca es 10
}

// Búsqueda con break - NO USAR en este curso
for (int i = 0; i < 100; i = i + 1) {
    if (valores[i] == buscado) {
        System.out.println("Encontrado en: " + i);
        break;  // Sale del lazo inmediatamente
    }
}

// Equivalente con bandera (USAR en este curso)
boolean encontrado = false;
int i = 0;
while (i < 100 && !encontrado) {
    if (valores[i] == buscado) {
        encontrado = true;
    } else {
        i = i + 1;
    }
}
if (encontrado) {
    System.out.println("Encontrado en: " + i);
}

// Imprimir solo impares con continue - NO USAR en este curso
for (int i = 0; i < 10; i = i + 1) {
    if (i % 2 == 0) {
        continue;  // Salta los números pares
    }
    System.out.println(i);  // Solo imprime impares
}

// Equivalente sin continue (USAR en este curso)
for (int i = 0; i < 10; i = i + 1) {
    if (i % 2 != 0) {  // Condición invertida
        System.out.println(i);
    }
}

switch (opcion) {
    case 1:
        hacerOpcion1();
        break;  // Permitido y necesario
    case 2:
        hacerOpcion2();
        break;  // Permitido y necesario
    default:
        hacerDefault();
        break;
}

int x = 0;

// En C esto compila y siempre es verdadero (asigna 5 a x)
// En Java esto NO compila:
// if (x = 5) { }  // Error: incompatible types: int cannot be converted to boolean

// Forma correcta:
if (x == 5) { }  // Comparación

int resultado;

if (condicion) {
    resultado = 10;
}

// Error de compilación: variable resultado might not have been initialized
// System.out.println(resultado);

// Correcto: inicializar en todas las ramas
if (condicion) {
    resultado = 10;
} else {
    resultado = 0;
}
System.out.println(resultado);  // OK

int cantidad = 5;
String texto = "hola";

// Estos NO compilan en Java (sí en C):
// if (cantidad) { }      // Error: int no es boolean
// while (texto) { }      // Error: String no es boolean

// Forma correcta:
if (cantidad != 0) { }     // Comparación explícita
while (texto != null) { }  // Comparación explícita

for (int i = 0; i < 10; i = i + 1) {
    System.out.println(i);
}
// i no existe aquí - evita errores

for (int i = 0; i < 5; i = i + 1) {
    // Esta i es diferente, sin conflicto
    System.out.println(i);
}