prioridad - operadores relacionales en java

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

¿Puedes ayudarme, por favor, a entender lo que significa el siguiente código?

x += 0.1;

El "conocimiento común" de la programación es que x += y es una notación abreviada equivalente de x = x + y . Siempre que x e 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 diferentes tipos, el comportamiento de las dos afirmaciones 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 una conversión implícita, mientras que para + necesitas lanzar explícitamente el segundo operando, de lo contrario obtendrías un error de compilación.

Cita de Java Puzzlers de Joshua Bloch:

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

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

short s = 2; s = s + 4;

obtendrás un error de compilación que int no se puede convertir en corto también si haces algo como a continuación:

float f = 4.6; f = f + 4.3;

obtendrá dos errores de compilación al establecer el doble de "4.6" en una variable flotante en ambas líneas y el error de la primera línea es lógico porque el uso de un sistema diferente para almacenar números y usar uno en lugar de otro puede causar la pérdida de datos; Dos ejemplos mencionados se pueden cambiar así:

s += 4 f += 4.3

que ambos tienen una conversión implícita detrás del código y no tienen errores de compilación; Otro punto digno de consideración es que los números en el rango del tipo de datos ''byte'' se almacenan 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 compilación:

byte b = 127

pero este tiene un error de hecho:

byte b = 128

porque 128 es un int en java; sobre los números largos, se recomienda utilizar una L después del número para la cuestión del desbordamiento de enteros como este:

long l = 2134324235234235L

en java no tenemos una sobrecarga de operadores como c ++ pero + = está sobrecargada solo para String y no para el digamos StringBuilder o StringBuffer y podemos usarlo en lugar del método String ''concat'' pero como sabemos String es inmutable y eso haga otro objeto y no cambiará el mismo objeto que antes:

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

Está bien;

Es uno de los operadores asignados . 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: Al hacer matemáticas de punto flotante, las cosas no siempre funcionan de la manera que crees .

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

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

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í ...