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); 
  }
}

pas compiler mais :

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

compile.

Answer 1

En Java, l'opérateur += est implicitement remplacé par le type de gauche. Cela vaut pour tous les opérateurs composés.

Answer 2

Int = int + double est essentiellement

int = double + double

et vous ne pouvez pas faire ça sans couler...

Le double int += force le résultat à être un int alors que l'autre nécessite un casting.

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

devrait compiler.

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

Answer 3

Double + int donne un double, donc double = double + int est légitime, voir JLS 5.1.2 Élargissement de la conversion primitive D'un autre côté int = double + int est "Narrowing Primitive Conversion" et nécessite un cast explicite.

Answer 4

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

Et un tableau de leurs significations : http://en.wikipedia.org/wiki/Java_bytecode_instruction_listings

Examinons donc le bytecode d'un simple code Java :

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)