Operatori composti Java

1. Panoramica

In questo tutorial, daremo uno sguardo agli operatori composti Java, ai loro tipi e al modo in cui Java li valuta.

Spiegheremo anche come funziona il casting implicito.

2. Operatori di assegnazione composti

Un operatore di assegnazione è un operatore binario che assegna il risultato del lato destro alla variabile del lato sinistro. Il più semplice è l' operatore di assegnazione "=" :

int x = 5;

Questa istruzione dichiara una nuova variabile x , assegna a x il valore di 5 e restituisce 5 .

Gli operatori di assegnazione composta sono un modo più breve per applicare un'operazione aritmetica o bit per bit e per assegnare il valore dell'operazione alla variabile sul lato sinistro.

Ad esempio, le seguenti due istruzioni moltiplicazione sono equivalenti, cioè un e b avrà lo stesso valore:

int a = 3, b = 3, c = -2; a = a * c; // Simple assignment operator b *= c; // Compound assignment operator

È importante notare che la variabile a sinistra di un operatore di assegnazione composto deve essere già dichiarata. In altre parole, gli operatori composti non possono essere utilizzati per dichiarare una nuova variabile.

Come l'operatore di assegnazione "=", gli operatori composti restituiscono il risultato assegnato dell'espressione:

long x = 1; long y = (x+=2);

Sia x che y manterranno il valore 3 .

L'assegnazione (x + = 2) fa due cose: in primo luogo, aggiunge 2 al valore della variabile x , che diventa 3; secondo, restituisce il valore dell'assegnazione, che è anche 3 .

3. Tipi di operatori di assegnazione composta

Java supporta 11 operatori di assegnazione composta. Possiamo raggrupparli in operatori aritmetici e bit per bit.

Esaminiamo gli operatori aritmetici e le operazioni che eseguono:

  • Incremento: + =
  • Decremento: - =
  • Moltiplicazione: * =
  • Divisione: / =
  • Modulo: % =

Quindi, abbiamo anche gli operatori bit per bit:

  • AND, binario: & =
  • OR esclusivo, binario: ^ =
  • OR inclusivo, binario: | =
  • Maiusc sinistro, binario: << =
  • Maiusc destro, binario: >> =
  • Sposta il riempimento con zero a destra: >>> =

Diamo uno sguardo ad alcuni esempi di queste operazioni:

// Simple assignment int x = 5; // x is 5 // Incrementation x += 5; // x is 10 // Decrementation x -= 2; // x is 8 // Multiplication x *= 2; // x is 16 // Modulus x %= 3; // x is 1 // Binary AND x &= 4; // x is 0 // Binary exclusive OR x ^= 4; // x is 4 // Binary inclusive OR x |= 8; // x is 12

Come possiamo vedere qui, la sintassi per utilizzare questi operatori è coerente.

4. Valutazione delle operazioni di assegnazione di composti

Esistono due modi in cui Java valuta le operazioni composte.

Innanzitutto, quando l'operando di sinistra non è un array, Java, nell'ordine, farà:

  1. Verificare che l'operando sia una variabile dichiarata
  2. Salva il valore dell'operando di sinistra
  3. Valuta l'operando di destra
  4. Eseguire l'operazione binaria come indicato dall'operatore composto
  5. Converti il ​​risultato dell'operazione binaria nel tipo della variabile di sinistra (casting implicito)
  6. Assegna il risultato convertito alla variabile di sinistra

Successivamente, quando l'operando di sinistra è un array, i passaggi da seguire sono leggermente diversi:

  1. Verifica l'espressione della matrice sul lato sinistro e genera un'eccezione NullPointerException o ArrayIndexOutOfBoundsException se non è corretta
  2. Salva l'elemento della matrice nell'indice
  3. Valuta l'operando di destra
  4. Verificare se il componente dell'array selezionato è un tipo primitivo o un tipo di riferimento, quindi continuare con gli stessi passaggi del primo elenco, come se l'operando di sinistra fosse una variabile.

Se uno qualsiasi dei passaggi della valutazione non riesce, Java non continua a eseguire i passaggi seguenti.

Diamo alcuni esempi relativi alla valutazione di queste operazioni a un elemento di array:

int[] numbers = null; // Trying Incrementation numbers[2] += 5;

Come ci aspetteremmo, questo genererà un'eccezione NullPointerException .

Tuttavia, se assegniamo un valore iniziale all'array:

int[] numbers = {0, 1}; // Trying Incrementation numbers[2] += 5;

Ci sbarazzeremo della NullPointerException, ma avremmo comunque un'eccezione ArrayIndexOutOfBoundsException , poiché l'indice utilizzato non è corretto.

Se lo risolviamo, l'operazione verrà completata con successo:

int[] numbers = {0, 1}; // Incrementation numbers[1] += 5; // x is now 6

Infine, la variabile x sarà 6 alla fine dell'assegnazione.

5. Casting implicito

Uno dei motivi per cui gli operatori composti sono utili è che non solo forniscono un modo più breve per le operazioni, ma anche le variabili cast implicitamente.

Formalmente, un'espressione di assegnazione composta della forma:

E1 op = E2

è equivalente a:

E1 - (T) (E1 op E2)

dove T è il tipo di E1 .

Let’s consider the following example:

long number = 10; int i = number; i = i * number; // Does not compile

Let’s review why the last line won’t compile.

Java automatically promotes smaller data types to larger data ones, when they are together in an operation, but will throw an error when trying to convert from larger to smaller types.

So, first, i will be promoted to long and then the multiplication will give the result 10L. The long result would be assigned to i, which is an int, and this will throw an error.

This could be fixed with an explicit cast:

i = (int) i * number;

Java compound assignment operators are perfect in this case because they do an implicit casting:

i *= number;

Questa istruzione funziona perfettamente, eseguendo il cast del risultato della moltiplicazione su int e assegnando il valore alla variabile a sinistra, i .

6. Conclusione

In questo articolo, abbiamo esaminato gli operatori composti in Java, fornendo alcuni esempi e diversi tipi di essi. Abbiamo spiegato come Java valuta queste operazioni.

Infine, abbiamo anche esaminato il casting implicito, uno dei motivi per cui questi operatori stenografici sono utili.

Come sempre, tutti gli snippet di codice menzionati in questo articolo possono essere trovati nel nostro repository GitHub.