Perché gli operatori di assegnazione composti + =, - =, * =, / = Java non richiedono il cast?

Fino ad oggi, ho pensato che per esempio:

i += j;

Era solo una scorciatoia per:

i = i + j;

Ma se proviamo questo:

int i = 5;
long j = 8;

Quindi i = i + j;non verrà compilato ma i += j;verrà compilato correttamente.

Vuol dire che in realtà i += j;è una scorciatoia per qualcosa di simile i = (type of i) (i + j)?

Come sempre con queste domande, JLS ha la risposta. In questo caso §15.26.2 Operatori di assegnazione composti . Un estratto:

Un'espressione di assegnazione composta del modulo E1 op= E2è equivalente a E1 = (T)((E1) op (E2)), dov'è Til tipo di E1, tranne che E1viene valutata una sola volta.

Un esempio citato da §15.26.2

[...] il seguente codice è corretto:

short x = 3;
x += 4.6;

e risulta che x abbia il valore 7 perché equivale a:

short x = 3;
x = (short)(x + 4.6);

In altre parole, il tuo presupposto è corretto.

Un buon esempio di questo casting sta usando * = o / =

byte b = 10;
b *= 5.7;
System.out.println(b); // prints 57

o

byte b = 100;
b /= 2.5;
System.out.println(b); // prints 40

o

char ch = '0';
ch *= 1.1;
System.out.println(ch); // prints '4'

o

char ch = 'A';
ch *= 1.5;
System.out.println(ch); // prints 'a'

Ottima domanda La specifica del linguaggio Java conferma il tuo suggerimento.

Ad esempio, il seguente codice è corretto:

short x = 3;
x += 4.6;

e risulta che x abbia il valore 7 perché equivale a:

short x = 3;
x = (short)(x + 4.6);

Sì,

fondamentalmente quando scriviamo

i += l; 

il compilatore converte questo in

i = (int)(i + l);

Ho appena controllato il .classcodice del file.

Davvero una buona cosa da sapere

è necessario eseguire il cast da longa int explicitlyin caso i = i + l contrario, verrà compilato e restituito l'output corretto. piace

i = i + (int)l;

o

i = (int)((long)i + l); // this is what happens in case of += , dont need (long) casting since upper casting is done implicitly.

ma in questo caso +=funziona bene perché l'operatore esegue implicitamente il cast del tipo dal tipo di variabile destra al tipo di variabile sinistra, quindi non è necessario eseguire il cast esplicitamente.

Il problema qui riguarda il cast di tipo.

Quando aggiungi int e long,

1. L'oggetto int viene impostato su long ed entrambi vengono aggiunti e si ottiene l'oggetto long.
2. ma l'oggetto lungo non può essere implicitamente assegnato a int. Quindi, devi farlo esplicitamente.

Ma +=è codificato in modo tale da digitare il casting.i=(int)(i+m)

In Java le conversioni di tipo vengono eseguite automaticamente quando il tipo di espressione sul lato destro di un'operazione di assegnazione può essere promosso in modo sicuro al tipo di variabile sul lato sinistro dell'assegnazione. Quindi possiamo tranquillamente assegnare:

 byte -> short -> int -> long -> float -> double. 

Lo stesso non funzionerà al contrario. Ad esempio, non possiamo convertire automaticamente un long in un int perché il primo richiede più spazio di archiviazione del secondo e, di conseguenza, le informazioni potrebbero andare perse. Per forzare tale conversione dobbiamo effettuare una conversione esplicita.
Tipo: conversione

A volte, una simile domanda può essere posta durante un'intervista.

Ad esempio, quando scrivi:

int a = 2;
long b = 3;
a = a + b;

non esiste un typecasting automatico. In C ++ non ci sarà alcun errore nella compilazione del codice sopra, ma in Java otterrai qualcosa del genere Incompatible type exception.

Quindi, per evitarlo, devi scrivere il tuo codice in questo modo:

int a = 2;
long b = 3;
a += b;// No compilation error or any exception due to the auto typecasting

La differenza principale è che con a = a + b, non è in corso il typecasting, quindi il compilatore si arrabbia con te per non aver fatto il typecasting. Ma con a += bciò che sta realmente facendo è la tipografia bin un tipo compatibile a. Quindi se lo fai

int a=5;
long b=10;
a+=b;
System.out.println(a);

Quello che stai davvero facendo è:

int a=5;
long b=10;
a=a+(int)b;
System.out.println(a);

Punto sottile qui ...

C'è un typecast implicito per i+jquando jè un doppio ed iè un int. Java SEMPRE converte un numero intero in un doppio quando c'è un'operazione tra di loro.

Per chiarire i+=jdove iè un numero intero ed jè un doppio può essere descritto come

i = <int>(<double>i + j)

Vedi: questa descrizione del casting implicito

Si potrebbe desiderare di typecast ja (int)in questo caso per la chiarezza.

Java Language Specification definisce E1 op= E2l'equivalente di E1 = (T) ((E1) op (E2))dove Tè un tipo di E1e E1viene valutato una volta .

Questa è una risposta tecnica, ma ti starai chiedendo perché sia ​​un caso. Bene, consideriamo il seguente programma.

public class PlusEquals {
    public static void main(String[] args) {
        byte a = 1;
        byte b = 2;
        a = a + b;
        System.out.println(a);
    }
}

Cosa stampa questo programma?

Hai indovinato 3? Peccato, questo programma non verrà compilato. Perché? Bene, succede che l'aggiunta di byte in Java sia definita per restituire unint . Credo che ciò sia dovuto al fatto che la Java Virtual Machine non definisce le operazioni di byte per il salvataggio su bytecode (dopo tutto c'è un numero limitato di quelle), l'uso delle operazioni di numeri interi è invece un dettaglio di implementazione esposto in una lingua.

Ma se a = a + bnon funziona, ciò significherebbe a += bche non funzionerebbe mai per i byte se E1 += E2fosse definito E1 = E1 + E2. Come mostra l'esempio precedente, sarebbe proprio così. Come hack per far +=funzionare l'operatore per byte e short, c'è un cast implicito. Non è un gran trucco, ma durante il lavoro di Java 1.0, l'obiettivo era quello di ottenere il rilascio del linguaggio per cominciare. Ora, a causa della compatibilità con le versioni precedenti, questo hack introdotto in Java 1.0 non può essere rimosso.