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


Fino ad oggi, ho pensato che ad esempio:

i += j;

è solo una scorciatoia per:

i = i + j;

Ma cosa succede se proviamo questo:

int i = 5;
long j = 8;

Poi i = i + j; non verrà compilato ma i += j; compilerà bene.

Significa che in effetti i += j; è una scorciatoia per qualcosa di simile i = (type of i) (i + j)?


3283
2018-01-03 10:10


origine


risposte:


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

Un'espressione di assegnazione composta della forma E1 op= E2 è equivalente a E1 = (T)((E1) op (E2)), dove T è il tipo di E1, salvo che E1 viene valutato solo una volta.

Un esempio citato da §15.26.2

[...] il seguente codice è corretto:

short x = 3;
x += 4.6;

e ha come risultato che x ha il valore 7 perché è equivalente a:

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

In altre parole, la tua ipotesi è corretta.


2210
2018-01-03 10:15



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'

442
2018-01-03 10:20



Ottima domanda Il Specifiche del linguaggio Java conferma il tuo suggerimento.

Ad esempio, il seguente codice è corretto:

short x = 3;
x += 4.6;

e ha come risultato che x ha il valore 7 perché è equivalente a:

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

223
2018-01-03 10:17



Sì,

fondamentalmente quando scriviamo

i += l; 

il compilatore lo converte in

i = (int)(i + l);

Ho appena controllato il .class codice del file.

Davvero una cosa buona da sapere


163
2018-01-03 10:19



devi lanciare da long a int  explicitly in caso di i = i + l  quindi compilerà e darà 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 caso di += funziona perfettamente perché l'operatore esegue implicitamente il tipo di trasmissione dal tipo di variabile corretta al tipo di variabile sinistra, quindi non è necessario eseguire il cast esplicito.


85
2018-01-03 10:15



Il problema qui riguarda il casting di tipo.

Quando aggiungi int e long,

  1. L'oggetto int è castato a lungo e entrambi vengono aggiunti e ottieni oggetti lunghi.
  2. ma l'oggetto lungo non può essere implicitamente convertito in int. Quindi, devi farlo esplicitamente.

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


56
2018-01-03 10:20



Nelle conversioni di tipo Java vengono eseguite automaticamente quando il tipo di espressione sul lato destro di un'operazione di assegnazione può essere promosso in sicurezza al tipo della variabile sul lato sinistro del compito. 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 una tale conversione, dobbiamo effettuare una conversione esplicita.
Tipo - Conversione


47
2018-01-23 05:50



A volte, una tale domanda può essere posta in un colloquio.

Ad esempio, quando scrivi:

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

non esiste un typecasting automatico. In C ++ non ci saranno errori nel compilare il codice sopra, ma in Java otterrai qualcosa di simile 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

37
2017-12-02 10:40



La principale differenza è che con a = a + b, non è in corso il typecasting, quindi il compilatore si arrabbia con te per non aver eseguito un typecasting. Ma con a += b, quello che sta facendo in realtà è il typecasting b a un tipo compatibile con a. Quindi se lo fai

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

Quello che stai facendo davvero è:

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

18
2018-06-07 23:27



Punto sottile qui ...

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

Chiarire i+=j dove i è un numero intero e j è un doppio può essere descritto come

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

Vedere: questa descrizione del casting implicito

Potresti voler digitare j a (int) in questo caso per chiarezza.


7
2018-01-18 20:07