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



how define (9)

Sì,

fondamentalmente quando scriviamo

i += l; 

il compilatore lo converte in

i = (int)(i + l);

Ho appena controllato il codice file .class .

Davvero una cosa buona da sapere

Fino ad oggi, ho pensato che ad 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; compilerà bene.

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


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'

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)


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


Ottima domanda La specifica della lingua 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);

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 , tranne 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.


La differenza principale è che con a = a + b , non si sta verificando il typecasting, e quindi il compilatore si arrabbia con te per non aver eseguito un typecasting. Ma con a += b , ciò che realmente sta facendo è typecasting b con 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);

Punto sottile qui ...

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

Per chiarire i+=j dove i è un intero e j è un doppio può essere descritto come

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

Vedi: questa descrizione del casting implicito

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


List<Integer> params = Arrays.asList (defaultStock, defaultWholesale, 
                                       defaultRetail, defaultDelivery);
int minParam = Collections.min (params);
negativeValue = minParam < 0;




java casting operators variable-assignment assignment-operator