Pourquoi les opérateurs d'attribution d'op-op ne sont-ils pas sûrs en Java?

Question

Je ne suis pas sûr que la question soit clairement formulée, mais un exemple sera plus clair.

j'ai découvert qui ne fonctionne pas en Java:

int a = ...; 
a = 5.0; 

mais cela:

int a = ...; 
a += 5.0; 

à savoir, il semble que l'opérateur = est de type sûr, mais + = est pas. Y a-t-il une raison profonde à cela ou est-ce juste une autre décision arbitraire que les concepteurs doivent prendre.

Answer 1

Pour rendre la vie plus facile.

Allons un peu plus loin. Considérez:

byte b; 
... 
++b; 

L'incrément fait vraiment:

b = (byte)(1 + (int)b); 

Même en utilisant += il ne peut pas trouver mieux:

b += b; 

est:

b = (byte)((int)b+(int)b); 

Ce rendrait ces opérateurs usel ess pour byte/short/char.

Bien sûr, je ne serai pas heureux jusqu'à ce que nous ayons des entiers de taille arbitraire.

Answer 2

La raison est que les opérations mathématiques font une coulée implicite:

a += 5.0; est évaluée comme suit:

a = (int) ((double) a + 5.0); 

Cession, cependant, exige un casting explicite.

(Il est peut-être flotter plutôt que doubler, je ne me souviens pas que Java traite comme littéraux décimaux.)