¿Qué hace el operador “+ =” en Java?

¿Puedes ayudarme a entender qué significa el siguiente código?

x += 0.1; 

El “conocimiento común” de la progtwigción es que x += y es una notación abreviada equivalente de x = x + y . Siempre que y sean del mismo tipo (por ejemplo, ambos son int s), puede considerar que las dos declaraciones son equivalentes.

Sin embargo, en Java, x += y no es idéntico a x = x + y en general.

Si y son de tipos diferentes, el comportamiento de las dos declaraciones difiere debido a las reglas del lenguaje. Por ejemplo, tengamos x == 0 (int) y y == 1.1 (doble):

  int x = 0; x += 1.1; // just fine; hidden cast, x == 1 after assignment x = x + 1.1; // won't compile! 'cannot convert from double to int' 

+= realiza un lanzamiento implícito, mientras que para + necesita lanzar explícitamente el segundo operando, de lo contrario, obtendría un error de comstackción.

Cita de Josué Bloch’s Java Puzzlers :

(…) las expresiones de asignación compuesta arrojan automáticamente el resultado del cálculo que realizan al tipo de la variable en su lado izquierdo. Si el tipo del resultado es idéntico al tipo de la variable, el molde no tiene efecto. Sin embargo, si el tipo de resultado es más amplio que el de la variable, el operador de asignación compuesto realiza una conversión de primitiva de estrechamiento silencioso [ JLS 5.1.3 ].

  • x += y es x = x + y
  • x -= y es x = x - y
  • x *= y es x = x * y
  • x /= y es x = x / y
  • x %= y es x = x % y
  • x ^= y es x = x ^ y
  • x &= y es x = x & y
  • x |= y es x = x | y x = x | y

y así …

Es uno de los operadores de asignación . Toma el valor de x , le agrega 0.1 y luego almacena el resultado de (x + 0.1) nuevamente en x .

Asi que:

 double x = 1.3; x += 0.1; // sets 'x' to 1.4 

Es funcionalmente idéntico a, pero más corto que:

 double x = 1.3; x = x + 0.1; 

NOTA: Cuando se realizan cálculos de punto flotante, las cosas no siempre funcionan de la manera en que crees que lo harán .

devtop += Math.pow(x[i] - mean, 2); agregará el resultado de la operación Math.pow(x[i] - mean, 2) a la variable devtop .

Un ejemplo más simple:

 int devtop = 2; devtop += 3; // devtop now equals 5 

devtop += Math.pow(x[i] - mean, 2); agrega Math.pow(x[i] - mean, 2) a devtop .

En Java, el tipo predeterminado de números como 2 o -2 (sin un componente fraccionario) es int y a diferencia de c # que no es un objeto y no podemos hacer algo como 2.tostring como en c # y el tipo predeterminado de números como 2.5 ( con un componente fraccional) es doble; Entonces, si escribes:

 short s = 2; s = s + 4; 

Obtendrás un error de comstackción que int no se puede convertir en corto también si lo haces de la siguiente manera:

 float f = 4.6; f = f + 4.3; 

obtendrá dos errores de comstackción para configurar doble ‘4.6’ a una variable flotante en ambas líneas y el error de primera línea es lógico porque flotante y doble usan un sistema diferente de almacenamiento de números y usar uno en lugar de otro puede causar la pérdida de datos; dos ejemplos mencionados pueden cambiarse así:

 s += 4 f += 4.3 

que ambos tienen un molde implícito detrás del código y no tienen errores de comstackción; Otro punto digno de consideración es que los números en el rango del tipo de datos ‘byte’ están en caché en java y, por lo tanto, los números -128 a 127 son de tipo byte en java y, por lo tanto, este código no tiene ningún error de comstackción:

 byte b = 127 

pero este tiene un error de hecho:

 byte b = 128 

porque 128 es un int en java; sobre números largos, se recomienda utilizar una L después del número para el desbordamiento de enteros de esta manera:

 long l = 2134324235234235L 

en Java no tenemos sobrecarga del operador como c ++, pero + = está sobrecargado solo para String y no para el StringBuilder o StringBuffer y podemos usarlo en lugar del método String ‘concat’, pero como sabemos, String es inmutable y eso hacer otro objeto y no cambiará el mismo objeto como antes:

 String str = "Hello"; str += "World"; 

Está bien;