1. Espressioni vs Istruzioni
Tutte le istruzioni in Java si dividono in due categorie: istruzioni (Statement) ed espressioni (Expression). Di solito si dice che un’istruzione viene eseguita, mentre un’espressione viene valutata. Ma questo non è l’aspetto principale.
La differenza principale tra istruzione ed espressione è che un’espressione ha un risultato di valutazione. Questo risultato, in primo luogo, ha un tipo e, in secondo luogo, può essere assegnato a qualcosa oppure usato in un’altra espressione.
Esempi:
| Codice | Note |
|---|---|
|
Istruzione |
|
Espressione, tipo boolean |
|
Espressione, il cui tipo coincide con il tipo della variabile i |
|
Espressione, il cui tipo coincide con il tipo della variabile x |
A cosa ci serve?
In primo luogo, possiamo sfruttare il fatto che molte istruzioni in realtà sono espressioni (hanno un risultato di valutazione). Per esempio, questo codice funziona:
int x, y, z;
x = y = z = 1; // x = (y = (z = 1));
In secondo luogo, possiamo ignorare il risultato della valutazione dell’espressione, se vogliamo.
console.nextLine(); // ignoriamo il risultato dell'input
Conviene ignorare il risultato di un’espressione, ad esempio, quando oltre al risultato essa compie anche qualcosa di utile e ci interessa l’azione, mentre il risultato no.
2. Operatore ternario
Questo trucchetto è più interessante del precedente. In Java esiste un operatore ternario (triplo) speciale. Per certi versi assomiglia a una forma abbreviata dell’operatore if–else:
Uslovie ? Vyrazhenie1 : Vyrazhenie2;Se la condizione è vera, viene valutata espressione1, altrimenti viene valutata espressione2. Dopo la condizione segue il punto interrogativo e le due espressioni sono separate dai due punti.
La differenza principale dell’operatore ternario rispetto a if-else è che l’operatore ternario è un’espressione; quindi il suo risultato può essere assegnato.
Ad esempio, vogliamo calcolare il minimo di due numeri. Con l’operatore ternario il codice sarà così:
int a = 2;
int b = 3;
int min = a < b ? a : b;
Oppure, supponiamo che tu debba assegnare alla variabile valori diversi a seconda di una certa condizione. Come farlo?
Prima opzione — usare l’operatore if-else:
int age = 25;
int money;
if (age > 30)
money = 100;
else
money = 50;
Seconda opzione — usare l’operatore ternario, cioè una forma abbreviata dell’operatore if-else:
int age = 25;
int money = age > 30 ? 100 : 50;
Che cosa conviene usare: l’operatore if-else o l’operatore ternario? Dal punto di vista delle prestazioni non c’è una gran differenza. È piuttosto una questione di leggibilità del codice. E questo è molto importante: il codice non deve solo funzionare correttamente, ma anche essere facile da leggere per altri programmatori.
Un criterio semplice può essere questo: se il codice sta in una sola riga — usa l’operatore ternario; se non sta in una sola riga — è meglio usare if-else.
3. Sfumature d’uso
Tipi di valori
È importante ricordare: entrambi i rami dell’operatore ternario (<valore_se_vero> e <valore_se_falso>) devono essere dello stesso tipo oppure compatibili (ad esempio, entrambi String o entrambi int).
Funziona:
int a = 10, b = 20;
int max = (a > b) ? a : b; // entrambi i rami sono int
Errore di compilazione:
int a = 10, b = 20;
// String e int sono incompatibili
String result = (a > b) ? "maggiore" : 0; // Errore di compilazione: non si può assegnare un int a una variabile di tipo String
Variante corretta:
int a = 10, b = 20;
String result = (a > b) ? "maggiore" : "minore o uguale";
Esempio: numeri
Calcoliamo il valore assoluto con l’operatore ternario:
int number = -5;
int abs = (number >= 0) ? number : -number;
System.out.println(abs); // 5
4. Integrare l’operatore ternario in un’applicazione
Scriviamo una piccola applicazione interattiva: oltre al saluto, il programma dirà all’utente quanti anni avrà tra un anno e indicherà se sarà maggiorenne.
System.out.print("Inserisci il tuo nome: ");
String name = console.nextLine();
System.out.print("Inserisci la tua età: ");
int age = console.nextInt();
int nextYear = age + 1;
String status = (nextYear >= 18) ? "maggiorenne" : "minorenne";
System.out.println("Ciao, " + name + "! L'anno prossimo avrai " + nextYear + ". Sarai " + status + ".");
Spieghiamo i dettagli:
La variabile status è calcolata tramite l’operatore ternario: se l’età tra un anno è almeno 18, l’utente sarà maggiorenne (o rimarrà tale).
5. Operatori ternari annidati — attenzione!
L’operatore ternario può essere annidato (in ciascun ramo può esserci un altro ternario). Ma… questo di solito fa venire mal di testa, soprattutto a chi leggerà il codice dopo di te (anche se sei tu tra 2 giorni).
Esempio: determinazione della categoria per età
String category = (age < 7) ? "prescolare" :
(age < 18) ? "studente" :
(age < 65) ? "adulto" : "pensionato";
Tabella decisionale:
| Età | Condizione | Risultato |
|---|---|---|
| < 7 | |
prescolare |
| 7–17 | |
studente |
| 18–64 | |
adulto |
| 65 e oltre | altrimenti | pensionato |
Questo codice è ancora leggibile, ma se la logica è più complessa — meglio usare if-else if-else.
6. Suggerimento: operatore ternario e tipo boolean
A volte ti capita di scrivere un’espressione del tipo:
boolean adult = (age >= 18) ? true : false;
Ma è ridondante. La stessa espressione (age >= 18) restituisce già un boolean. Quindi si può ridurre a:
boolean adult = (age >= 18);
GO TO FULL VERSION