if-else en Java: sentencias condicionales con ejemplos

Tomar decisiones con if

Los programas necesitan reaccionar ante los datos: aprobado o suspenso, en stock o agotado, válido o no. La sentencia if es la forma en que Java elige qué código ejecutar según una condición.

Un if toma una condición booleana entre paréntesis y ejecuta el bloque entre llaves solo cuando esa condición es true:

public class Main {
    public static void main(String[] args) {
        int score = 72;

        if (score >= 60) {
            System.out.println("You passed!");
        }

        System.out.println("Done grading.");
    }
}

La condición score >= 60 es true, así que el mensaje se imprime. La línea posterior a la llave de cierre siempre se ejecuta: está fuera del if. Cambia score a 40 y la línea de "passed" se omite por completo.

A diferencia de C, Java no te deja poner un número donde corresponde un booleano. if (score) es un error de compilación: la condición debe ser una expresión boolean real construida a partir de comparaciones (>, >=, ==, !=) o lógica booleana (&&, ||, !).

Añadir un else

else te da el camino "en caso contrario": código que se ejecuta solo cuando la condición es false:

public class Main {
    public static void main(String[] args) {
        int hour = 20;

        if (hour < 12) {
            System.out.println("Good morning");
        } else {
            System.out.println("Good evening");
        }
    }
}

Se ejecuta exactamente uno de los dos bloques: nunca los dos, nunca ninguno. El else no tiene condición propia; simplemente captura todo lo que el if no cubrió.

Encadenar con else if

Cuando hay más de dos resultados, encadena condiciones con else if. Java las comprueba de arriba abajo y ejecuta el primer bloque cuya condición sea verdadera, y luego omite el resto:

public class Main {
    public static void main(String[] args) {
        int score = 84;
        char grade;

        if (score >= 90) {
            grade = 'A';
        } else if (score >= 80) {
            grade = 'B';
        } else if (score >= 70) {
            grade = 'C';
        } else {
            grade = 'F';
        }

        System.out.println("Grade: " + grade);
    }
}

El orden importa. Como 84 se comprueba primero contra >= 90 (falso) y luego contra >= 80 (verdadero), se detiene en B y ni siquiera prueba los límites inferiores. Por eso tampoco necesitas escribir score >= 80 && score < 90: llegar a la segunda rama ya garantiza que score era menor que 90. Pon primero tu condición más estricta o de mayor prioridad.

El else final es tu caso por defecto. Omitirlo aquí sería un error de compilación, ya que grade podría quedar sin asignar al momento de imprimirla.

Comparar valores: == frente a equals()

El error con if más común en Java es comparar cadenas con ==. Para tipos primitivos (int, double, char, boolean) == es correcto. Para objetos, == pregunta "¿es el mismo objeto en memoria?" mientras que .equals() pregunta "¿tienen el mismo contenido?", y casi siempre quieres esto último:

public class Main {
    public static void main(String[] args) {
        String input = new String("yes");

        if (input == "yes") {
            System.out.println("matched with ==");
        }

        if (input.equals("yes")) {
            System.out.println("matched with equals()");
        }
    }
}

Solo se imprime el segundo mensaje. El new String("yes") es un objeto distinto del literal "yes", así que == es false, pero el texto es idéntico, así que .equals() es true. Regla práctica: para primitivos usa ==, para objetos usa .equals().

Un truco seguro para evitar una NullPointerException cuando la variable podría ser null: pon el literal primero, if ("yes".equals(input)), ya que un literal nunca es null.

Combinar y anidar condiciones

Puedes combinar condiciones con && (y), || (o) y ! (no), o anidar un if dentro de otro cuando una comprobación solo tiene sentido después de que pase una anterior:

public class Main {
    public static void main(String[] args) {
        int age = 25;
        boolean hasLicense = true;

        if (age >= 18 && hasLicense) {
            System.out.println("Can drive");
        } else {
            System.out.println("Cannot drive");
        }

        // anidamiento: comprobar lo segundo solo si lo primero se cumple
        if (age >= 18) {
            if (hasLicense) {
                System.out.println("Eligible and licensed");
            }
        }
    }
}

&& y || hacen cortocircuito: en a && b, si a es falso Java nunca evalúa b. Eso es útil para protegerse de errores: if (s != null && s.length() > 0) es seguro porque la comprobación de longitud se omite cuando s es null. Prefiere combinar con && antes que anidar en profundidad cuando puedas; lo plano se lee con más claridad que una pirámide de llaves.

Una trampa clásica: un solo = es asignación, == es comparación. Escribir if (x = 5) es un error de compilación para int (bien), pero if (flag = true) sobre un boolean compila y asigna en silencio: ten cuidado con eso.

El operador ternario

Cuando lo único que quieres es elegir entre dos valores, el operador ternario ?: es un compacto de una sola línea. Lee condition ? a : b como "si la condición entonces a si no b":

public class Main {
    public static void main(String[] args) {
        int age = 15;

        String label = age >= 18 ? "adult" : "minor";
        System.out.println(label);

        int a = 7, b = 3;
        int max = a > b ? a : b;
        System.out.println("max = " + max);
    }
}

El ternario produce un valor que puedes asignar o pasar directamente. Resérvalo para selecciones simples: si alguna rama necesita varias sentencias o lógica de verdad, un if-else completo sigue siendo legible donde un ternario anidado se convierte rápidamente en un acertijo.

Una trampa: las llaves opcionales

Java te deja omitir las llaves cuando una rama tiene una sola sentencia, pero eso invita a un error sutil. La indentación miente:

if (loggedIn)
    System.out.println("Welcome");
    System.out.println("Loading dashboard");   // NOT part of the if!

Solo la primera línea está controlada por el if; la segunda siempre se ejecuta sin importar nada, a pesar de que la indentación sugiera lo contrario. Usa siempre llaves, incluso para una sola línea, y toda esta clase de error desaparece.

Siguiente: switch

Las cadenas if-else if son perfectas cuando cada rama comprueba una condición distinta. Pero cuando estás comparando un único valor contra muchas posibilidades fijas (un nombre de día, una opción de menú, un enum), una larga escalera de else if se vuelve repetitiva. La sentencia switch está hecha exactamente para eso, y es la siguiente página.