Guida Java interattiva: if-else

Q: Come si scrive un'istruzione if-else in Java?

Metti una condizione booleana tra parentesi dopo if, poi il codice da eseguire tra graffe, e un blocco else facoltativo per quando la condizione è falsa: if (score >= 60) { System.out.println("Pass"); } else { System.out.println("Fail"); }. La condizione deve restituire un boolean: Java non accetta un int come fa il C.

Q: Qual è la differenza tra == ed equals() in un if in Java?

== verifica se due riferimenti puntano allo stesso oggetto, mentre .equals() confronta il contenuto. Per i primitivi come int usa ==. Per gli oggetti, soprattutto String, usa .equals(): if (name.equals("Sam")), non if (name == "Sam"). Usare == sulle stringhe è in assoluto il bug più comune negli if in Java.

Q: Cos'è l'operatore ternario in Java?

L'operatore ternario condition ? valueIfTrue : valueIfFalse è un if-else compatto che produce un valore. Per esempio String label = age >= 18 ? "adult" : "minor"; assegna uno di due valori in base alla condizione. Usalo per scegliere semplicemente un valore; passa a un if-else completo quando in ogni ramo c'è della logica da eseguire.

Prendere decisioni con if

I programmi devono reagire ai dati: promosso o bocciato, disponibile o esaurito, valido o no. L'istruzione if è il modo in cui Java sceglie quale codice eseguire in base a una condizione.

Un if riceve una condizione booleana tra parentesi ed esegue il blocco tra graffe solo quando quella condizione è 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 condizione score >= 60 è true, quindi il messaggio viene stampato. La riga dopo la graffa di chiusura viene sempre eseguita: sta fuori dall'if. Cambia score in 40 e la riga "passed" viene saltata del tutto.

A differenza del C, Java non ti permette di mettere un numero dove serve un booleano. if (score) è un errore di compilazione: la condizione deve essere una vera espressione boolean costruita con confronti (>, >=, ==, !=) o logica booleana (&&, ||, !).

Aggiungere un else

else ti dà il percorso "altrimenti": codice che viene eseguito solo quando la condizione è 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");
        }
    }
}

Viene eseguito esattamente uno dei due blocchi: mai entrambi, mai nessuno. else non ha una condizione propria; cattura semplicemente tutto ciò che l'if non ha catturato.

Concatenare con else if

Quando ci sono più di due esiti, concatena le condizioni con else if. Java le controlla dall'alto verso il basso ed esegue il primo blocco la cui condizione è vera, poi salta il 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);
    }
}

L'ordine conta. Dato che 84 viene confrontato prima con >= 90 (falso), poi con >= 80 (vero), si ferma a B e non verifica nemmeno le soglie più basse. È anche per questo che non devi scrivere score >= 80 && score < 90: arrivare al secondo ramo garantisce già che score fosse sotto 90. Metti per prima la condizione più stretta o con priorità più alta.

L'else finale è il tuo "tutto il resto". Ometterlo qui sarebbe un errore di compilazione, perché grade potrebbe non essere assegnato al momento della stampa.

Confrontare valori: == ed equals()

Il bug più comune negli if in Java è confrontare le stringhe con ==. Per i primitivi (int, double, char, boolean) == è corretto. Per gli oggetti, == chiede "è lo stesso oggetto in memoria?" mentre .equals() chiede "hanno lo stesso contenuto?", e quasi sempre ti serve la seconda domanda:

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()");
        }
    }
}

Viene stampato solo il secondo messaggio. new String("yes") è un oggetto diverso dal letterale "yes", quindi == è false, ma il testo è identico, quindi .equals() è true. Regola pratica: i primitivi usano ==, gli oggetti usano .equals().

Un trucco sicuro per evitare una NullPointerException quando la variabile potrebbe essere null: metti prima il letterale, if ("yes".equals(input)), perché un letterale non è mai null.

Combinare e annidare condizioni

Puoi combinare le condizioni con && (e), || (o) e ! (non), oppure annidare un if dentro un altro quando un controllo ha senso solo se il precedente è passato:

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");
        }

        // annidamento: verifica la seconda cosa solo se vale la prima
        if (age >= 18) {
            if (hasLicense) {
                System.out.println("Eligible and licensed");
            }
        }
    }
}

&& e || usano la valutazione a corto circuito: in a && b, se a è falso Java non valuta mai b. È comodo per proteggersi dagli errori: if (s != null && s.length() > 0) è sicuro perché il controllo della lunghezza viene saltato quando s è null. Quando puoi, preferisci combinare con && piuttosto che annidare in profondità: un codice piatto si legge meglio di una piramide di graffe.

Una trappola classica: un solo = è un'assegnazione, == è un confronto. Scrivere if (x = 5) è un errore di compilazione per un int (bene), ma if (flag = true) su un boolean compila e assegna in silenzio: fai attenzione.

L'operatore ternario

Quando vuoi solo scegliere tra due valori, l'operatore ternario ?: è una soluzione compatta in una riga. Leggi condition ? a : b come "se condizione allora a altrimenti 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);
    }
}

Il ternario produce un valore che puoi assegnare o passare direttamente. Usalo per scelte semplici: se uno dei rami richiede più istruzioni o vera logica, un if-else completo resta leggibile, mentre un ternario annidato diventa presto un rompicapo.

Una trappola: le graffe facoltative

Java ti permette di omettere le graffe quando un ramo ha una sola istruzione, ma questo apre la porta a un bug sottile. L'indentazione inganna:

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

Solo la prima riga è controllata dall'if; la seconda viene sempre eseguita, anche se l'indentazione suggerisce il contrario. Usa sempre le graffe, anche per una sola riga, e questo intero tipo di errore sparisce.

Prossimo passo: switch

Le catene if-else if sono perfette quando ogni ramo verifica una condizione diversa. Ma quando confronti un solo valore con molte possibilità fisse, come il nome di un giorno, una scelta di menu o un enum, una lunga scala di else if diventa ripetitiva. L'istruzione switch è fatta proprio per questo, ed è l'argomento della prossima pagina.

Domande frequenti

Come si scrive un'istruzione if-else in Java?

Metti una condizione booleana tra parentesi dopo if, poi il codice da eseguire tra graffe, e un blocco else facoltativo per quando la condizione è falsa: if (score >= 60) { System.out.println("Pass"); } else { System.out.println("Fail"); }. La condizione deve restituire un boolean: Java non accetta un int come fa il C.

Qual è la differenza tra == ed equals() in un if in Java?

== verifica se due riferimenti puntano allo stesso oggetto, mentre .equals() confronta il contenuto. Per i primitivi come int usa ==. Per gli oggetti, soprattutto String, usa .equals(): if (name.equals("Sam")), non if (name == "Sam"). Usare == sulle stringhe è in assoluto il bug più comune negli if in Java.

Cos'è l'operatore ternario in Java?

L'operatore ternario condition ? valueIfTrue : valueIfFalse è un if-else compatto che produce un valore. Per esempio String label = age >= 18 ? "adult" : "minor"; assegna uno di due valori in base alla condizione. Usalo per scegliere semplicemente un valore; passa a un if-else completo quando in ogni ramo c'è della logica da eseguire.

Concetti correlati