Sfumature di lavorare con vari operatori

1. Operazioni booleane

Gli operatori |e &possono essere applicati non solo ai numeri, ma anche alle espressioni booleane.

Ma, come già sai, ci sono &&e ||operatori. Perché dovremmo usare |invece di ||e &invece di &&? C'è qualche punto in questo? Sembra che ci sia. A volte.

Gli operatori logici ||e &&vengono eseguiti da sinistra a destra seguendo un cosiddetto principio pigro .

(expression1) || (expression2) || (expression3)

Se expression1 è uguale a true, non ha senso valutare expression2 e expression3: il risultato sarà truecomunque.

Di conseguenza, quando si valutano le espressioni (vengono valutate da sinistra a destra), non appena si ottiene true, la valutazione del resto delle espressioni viene saltata . E se expression2 e expression3includi chiamate di metodo, questi metodi non verranno chiamati !

Lo stesso vale per l' &&operatore logico:

(expression1) && (expression2) && (expression3)

Se expression1è uguale a false, non ha senso valutare expression2e expression3: il risultato sarà falsecomunque.

Questo è un fatto importante che ti permette di scrivere cose come:

String s = null;
if (s != null && s.length() > 0) {

L'esempio sopra non ti darà mai una NullPointerException , perché s.length()verrà eseguita solo se la prima parte s! = nullè true.

Se sè uguale a null, la parte a sinistra dell'operatore &&è false, quindi il risultato dell'intera espressione booleana è false, quindi la parte a destra ( s.length() > 0) non viene valutata.

2. Precedenza delle operazioni in Java

Come probabilmente ricorderai dalla lezione di matematica del liceo, l'operatore di moltiplicazione ha una precedenza maggiore rispetto all'operatore di addizione. Le parentesi hanno una precedenza ancora maggiore: le espressioni tra parentesi vengono valutate per prime, quindi la moltiplicazione e la divisione, quindi l'addizione e la sottrazione.

Anche gli operatori in Java hanno un ordine di precedenza. La differenza è che a) ce ne sono leggermente di più, b) per alcuni operatori, gli operandi vengono valutati da sinistra a destra, mentre per altri da destra a sinistra.

Ecco una tabella con tutti gli operatori Java:

La riga superiore contiene gli operatori con la precedenza più alta. Le parentesi ()vengono utilizzate per impostare esplicitamente la priorità. Le parentesi quadre []vengono utilizzate per accedere a un elemento in un indice specifico di una variabile di matrice. L'operatore punto ( .) viene utilizzato per accedere a campi e metodi utilizzando un riferimento a un oggetto o una classe.

Più basso è l'operatore nella tabella, minore è la sua precedenza.

Se usi più operatori in un'espressione, non essere pigro: aggiungi le parentesi.

In Java, puoi scrivere qualcosa come if (a & 1<< b > ~c), ma non dovresti. Stai scrivendo codice non solo per il compilatore, ma anche per altri programmatori. Più il codice è leggibile, meglio è.

3. Incremento di prefisso e suffisso

Come già sai, Java ha un operatore di incremento ( ++) e un operatore di decremento ( --). Rispettivamente, aumentano e diminuiscono il valore di una variabile di 1.

Quello che probabilmente non sai è che ci sono due tipi di questi operatori: prefix (l'operatore è posto prima della variabile) e postfix (l'operatore è posto dopo la variabile). E due tipi di operatori funzionano in modo leggermente diverso.

In Java, puoi scrivere un'espressione come questa:

int a = 5;
int b = a++;

Se l' ++operatore appare dopo una variabile e la variabile fa parte di un'espressione (come nell'esempio precedente), l'espressione utilizzerà il valore corrente della variabile e solo successivamente la variabile verrà aumentata di 1.

In altre parole, accadrà qualcosa del genere:

int a = 5;
int b = a;
a = a + 1;

Cioè, bsarà 5, non 6come potresti pensare a prima vista.

Se l' ++operatore è prima della variabile e la variabile fa parte di un'espressione, verrà prima aumentata di 1e solo successivamente il suo valore verrà utilizzato nell'espressione.

int a = 5;
int b = ++a;

int a = 5;
a = a + 1;
int b = a;

Qui, bsarà uguale a 6.

C'è anche un esempio usato dai programmatori Java per determinare se qualcun altro è anche un programmatore Java:

int a = 5;
int b = ++a + ++a;

Sì, puoi scriverlo anche tu.

Questo esempio verrà compilato correttamente e si trasformerà in qualcosa del genere:

int a = 5;

a = a + 1;
int v1 = a;

a = a + 1;
int v2 = a;

int b = v1 + v2;

Per l' --operatore, tutto è esattamente lo stesso.