Quelle est la différence entre double a = a + int b et int a + = double b?

Question

Pourquoi:

public class Addition { 
    public static void main() { 
    int a = 0; 
    double b = 1.0; 
    a = a + b; 
    System.out.println(a); 
    } 
} 

ne compilera pas, mais:

public class Addition { 
    public static void main() { 
    int a = 0; 
    double b = 1.0; 
    a += b; 
    System.out.println(a); 
    } 
} 

compiles.

Answer 1

int = int + double est essentiellement

int = doubles +

et vous ne pouvez pas faire cela sans jeter ...

int + = doubles forces le résultat à un tout int l'autre nécessite un casting.

Donc a = (int) (a + b);

doit compiler.

Edit: comme demandé dans les commentaires ... voici un lien vers plus de lecture (pas la lecture plus facile, mais les informations les plus correctes): http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.26.2

Answer 2

En Java + = opérateur a une distribution implicite à la type de main gauche. Cela vaut pour tous les opérateurs composés.

Answer 3

double + int retourne double, donc à double = double + int est légitime, voir JLS 5.1.2 Conversion primitive élargissement d'autre part int = double + int est "Fusionner Conversion primitive" et exige explicitement

coulé

Answer 4

Comme tout le monde l'a déjà dit, le + = a une distribution implicite. Pour illustrer cela, je vais utiliser une application que j'ai écrite il y a quelques temps et qui est parfaite pour ce genre de questions. Il est un désassembleur en ligne afin que vous puissiez vérifier le bytecode réel qui est en cours de production: http://javabytes.herokuapp.com/

Et une table de leurs significations: http://en.wikipedia.org/wiki/Java_bytecode_instruction_listings

Donc, nous allons jeter un oeil à la bytecode de certains code Java simple:

int i = 5; 
long j = 8; 
i += j; 

Code désassemblé. Mes commentaires auront un // devant.

Code: 
     0: iconst_5 //load int 5 onto stack 
     1: istore_0 //store int value into variable 0 (we called it i) 
     2: ldc2_w #2; //long 8l 
        //load long 8 value onto stack. Note the long 8l above 
        //is not my comment but how the disassembled code displays 
        //the value long 8 being used with the ldc2_w instruction 
     5: lstore_1 //store long value into variable 1 (we called it j) 
     6: iload_0 //load int value from variable 0 
     7: i2l  //convert int into a long. At this point we have 5 long 
     8: lload_1 //load value from variable 1 
     9: ladd  //add the two values together. We are adding two longs 
        //so it's no problem 
     10: l2i  //THIS IS THE MAGIC. This converts the sum back to an int 
     11: istore_0 //store in variable 0 (we called it i)