1. Introduzione
Cominciamo con un’analogia quotidiana. Immaginate una ricetta:
Mescolate farina, uova e zucchero, montate, aggiungete il burro, montate di nuovo.
Sembra strano? E ora immaginate che tra le parole «montate» e «aggiungete» ci sia una virgola o delle parentesi. L’ordine delle azioni diventa subito più chiaro.
In programmazione una situazione simile si presenta quando scrivete un’espressione complessa:
boolean result = a > 0 && b < 10 || c == 3;
Qual è l’ordine? Che cosa viene valutato per primo: a > 0 && b < 10, poi || c == 3? Oppure il contrario?
Senza un ordine di valutazione chiaro il computer può «confondere gli ingredienti» e il risultato sarà inaspettato.
2. Precedenza degli operatori in Java
Java (come la maggior parte dei linguaggi di programmazione) usa una tabella di precedenza degli operatori.
Gli operatori con precedenza più alta vengono valutati prima di quelli con precedenza più bassa.
Guardate la parte più importante di questa tabella (per le espressioni condizionali):
| Operatore | Descrizione | Precedenza |
|---|---|---|
|
Parentesi | la più alta |
|
NOT logico | alta |
|
Uguale / diverso da | media |
|
Confronti | media |
|
AND logico | più bassa |
|
OR logico | ancora più bassa |
(Esistono anche operatori aritmetici — hanno una precedenza più alta di quelli logici.)
Regola principale
Gli operatori AND (&&) hanno una precedenza più alta di OR (||),
cioè prima viene valutato AND, poi OR. Non a caso AND è una moltiplicazione logica, mentre OR è un’addizione.
Diagramma di flusso della valutazione della precedenza delle condizioni
graph LR
A["a > 0"] --&&--> B["b < 10"]
B --||--> C["c == 3"]
(In pratica: a > 0 && b < 10 || c == 3 — prima si valuta a > 0 && b < 10, poi il risultato viene combinato con c == 3 tramite ||.)
3. Direzione degli operatori: da sinistra a destra e viceversa
Oltre alla precedenza, c’è anche una parola: associatività.
È la regola che stabilisce in quale direzione vengono valutati gli operatori, quando sono «affiancati» e hanno la stessa precedenza.
Esempio:
boolean a = true, b = false, c = true;
boolean result = a && b && c;
Domanda: come verrà valutata?
Risposta: l’associatività di && — da sinistra a destra.
Quindi prima a && b, poi il risultato con c.
Applicato alle condizioni:
| Operatore | Associatività |
|---|---|
|
da sinistra a destra |
|
da destra a sinistra |
4. Le parentesi — il tuo miglior alleato nelle condizioni complesse
Qui inizia la magia (e la salvezza). Quando scrivete un’espressione, le parentesi cambiano la precedenza e rendono il vostro codice più chiaro e sicuro.
Esempio 1 (senza parentesi):
// Vogliamo: "Se l'utente è adulto e cittadino, oppure se ha un permesso speciale"
boolean isAdult = age >= 18;
boolean isCitizen = country.equals("Bielorussia");
boolean hasPermit = hasSpecialPass == true;
if (isAdult && isCitizen || hasPermit)
{
System.out.println("Accesso consentito!");
}
Come valuta Java:
Prima calcola isAdult && isCitizen, poi combina il risultato con hasPermit tramite ||.
- Supponiamo: isAdult = true, isCitizen = false, hasPermit = true
- isAdult && isCitizen → true && false → false
- false || true → true
Cioè, se la persona ha un permesso speciale, passa comunque.
E se non ha il permesso ma è un cittadino adulto — passa lo stesso.
Esempio 2 (con parentesi):
if (isAdult && (isCitizen || hasPermit))
{
System.out.println("Accesso consentito!");
}
Ora il programma verifica prima: isCitizen || hasPermit, e poi usa quel risultato insieme a isAdult.
Quindi bisogna essere maggiorenni e (o cittadini, o avere un permesso speciale).
Una piccola differenza nelle parentesi — una grande differenza nella logica!
GO TO FULL VERSION