¿Por qué los operadores de asignación compuesta + =, - =, * =, / = de Java no requieren conversión?

Hasta hoy, pensé que, por ejemplo:

i += j;

Era solo un atajo para:

i = i + j;

Pero si intentamos esto:

int i = 5;
long j = 8;

Entonces i = i + j;no se compilará pero i += j;se compilará bien.

¿Significa que de hecho i += j;es un atajo para algo como esto i = (type of i) (i + j)?

Como siempre con estas preguntas, el JLS tiene la respuesta. En este caso, §15.26.2 Operadores de asignación compuesta . Un extracto:

Una expresión de asignación compuesta de la forma E1 op= E2es equivalente a E1 = (T)((E1) op (E2)), donde Tes el tipo de E1, excepto que E1se evalúa solo una vez.

Un ejemplo citado de §15.26.2

[...] el siguiente código es correcto:

short x = 3;
x += 4.6;

y resulta en x teniendo el valor 7 porque es equivalente a:

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

En otras palabras, su suposición es correcta.

Un buen ejemplo de este casting es usar * = 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'

Muy buena pregunta La especificación del lenguaje Java confirma su sugerencia.

Por ejemplo, el siguiente código es correcto:

short x = 3;
x += 4.6;

y resulta en x teniendo el valor 7 porque es equivalente a:

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

Si,

básicamente cuando escribimos

i += l; 

el compilador convierte esto a

i = (int)(i + l);

Acabo de comprobar el .classcódigo del archivo.

Realmente es algo bueno saber

debe convertir desde longa int explicitlyen caso de i = i + l que se compile y dé la salida correcta. me gusta

i = i + (int)l;

o

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

pero en caso de +=que simplemente funcione bien porque el operador realiza implícitamente el tipo de conversión de tipo de variable derecha a tipo de variable izquierda, por lo que no es necesario emitir explícitamente.

El problema aquí implica la conversión de tipos.

Cuando agregas int y long,

1. El objeto int se convierte en largo y ambos se agregan y obtienes un objeto largo.
2. pero el objeto largo no se puede convertir implícitamente en int. Entonces, tienes que hacer eso explícitamente.

Pero +=está codificado de tal manera que sí lo hace.i=(int)(i+m)

En Java, las conversiones de tipo se realizan automáticamente cuando el tipo de expresión en el lado derecho de una operación de asignación se puede promover de forma segura al tipo de la variable en el lado izquierdo de la asignación. Por lo tanto, podemos asignar con seguridad:

 byte -> corto -> int -> largo -> flotante -> doble. 

Lo mismo no funcionará al revés. Por ejemplo, no podemos convertir automáticamente un largo a int porque el primero requiere más almacenamiento que el segundo y, en consecuencia, se puede perder información. Para forzar tal conversión debemos llevar a cabo una conversión explícita.
Tipo - Conversión

A veces, tal pregunta se puede hacer en una entrevista.

Por ejemplo, cuando escribes:

int a = 2;
long b = 3;
a = a + b;

No hay encasillamiento automático. En C ++ no habrá ningún error al compilar el código anterior, pero en Java obtendrá algo así Incompatible type exception.

Para evitarlo, debe escribir su código de esta manera:

int a = 2;
long b = 3;
a += b;// No compilation error or any exception due to the auto typecasting

La principal diferencia es que con a = a + bno hay ningún tipo de conversión de texto, por lo que el compilador se enoja con usted por no hacerlo. Pero con a += blo que realmente está haciendo es convertir ba un tipo compatible a. Entonces si lo haces

int a=5;
long b=10;
a+=b;
System.out.println(a);

Lo que realmente estás haciendo es:

int a=5;
long b=10;
a=a+(int)b;
System.out.println(a);

Punto sutil aquí ...

Hay un tipo de letra implícito para i+jcuando jes un doble y ies un int. Java SIEMPRE convierte un número entero en un doble cuando hay una operación entre ellos.

Para aclarar i+=jdónde ies un número entero y jun doble se puede describir como

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

Ver: esta descripción del casting implícito

Es posible que desee encasillado ja (int)en este caso, para mayor claridad.

La especificación del lenguaje Java define E1 op= E2ser equivalente a E1 = (T) ((E1) op (E2))donde Tes un tipo de E1y E1se evalúa una vez .

Esa es una respuesta técnica, pero puede que se pregunte por qué es así. Bueno, consideremos el siguiente programa.

public class PlusEquals {
    public static void main(String[] args) {
        byte a = 1;
        byte b = 2;
        a = a + b;
        System.out.println(a);
    }
}

¿Qué imprime este programa?

¿Adivinaste 3? Lástima, este programa no se compilará. ¿Por qué? Bueno, sucede que la adición de bytes en Java se define para devolver unint . Esto, creo que fue porque la máquina virtual Java no define operaciones de byte para guardar en códigos de byte (después de todo, hay un número limitado de ellas), el uso de operaciones enteras es un detalle de implementación expuesto en un lenguaje.

Pero si a = a + bno funciona, eso significaría a += bque nunca funcionaría para bytes si se E1 += E2definiera como tal E1 = E1 + E2. Como muestra el ejemplo anterior, ese sería el caso. Como un truco para hacer que el +=operador funcione para bytes y cortos, hay un elenco implícito involucrado. No es un gran truco, pero durante el trabajo de Java 1.0, el enfoque se centró en liberar el lenguaje para empezar. Ahora, debido a la compatibilidad con versiones anteriores, este truco introducido en Java 1.0 no se pudo eliminar.