Java opérateur +=

Question

Jusqu'à aujourd'hui je pensais que par exemple:

i += j;

est juste un raccourci pour:

i = i + j;

Mais que faire si nous essayons ceci:

int i = 5;
long j = 8;

Ensuite, i = i + j; ne compile pas mais i += j; de compiler amende.

Veut-il dire qu'en fait, i += j; est un raccourci pour quelque chose comme cela i = (type of i) (i + j)?

J'ai essayé de googler pour elle, mais ne pouvait pas trouver quelque chose de pertinent.

Answer 1

Comme toujours avec ces questions, le JLS détient la réponse. Dans ce cas §15.26.2 Composé des Opérateurs d'Affectation. Un extrait:

Un composé expression d'affectation de la forme E1 op= E2 est équivalent à E1 = (T)((E1), op (E2)), où T est le type de E1, sauf que E1 est évaluée qu'une seule fois.

Un exemple cité plus haut ( §15.26.2

[...] le code suivant est correct:

short x = 3;
x += 4.6;

et les résultats dans x ayant la valeur 7, parce que c'est équivalent à:

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

En d'autres termes, votre hypothèse est correcte.

Answer 2

Un bon exemple de ce casting est à l'aide de *=, /=

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

ou

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

ou

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

ou

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

Answer 3

Très bonne question. La Java Language specification confirme votre suggestion.

Par exemple, le code suivant est correct:

 short x = 3;
 x += 4.6;

et les résultats dans x ayant la valeur 7, parce que c'est équivalent à:

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

Answer 4

Oui,

fondamentalement, quand on écrit

i += l; 

compilateur est la conversion de ce à

i = (int)(i + l);

Je viens de vérifier l' .class le fichier de code.

Vraiment une bonne chose à savoir

Answer 5

vous avez besoin de jeter de long de int explicitly dans le cas d' i = i + l puis de compiler et de donner les bons de sortie. comme

i = i + (int)l;

ou

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

mais dans le cas d' += ça marche bien parce que l'opérateur implicitement le type coulée de type de droit de la variable de type de gauche de la variable n'a pas besoin de cast explicite.