Что делает оператор "+ =" в Java?

Ответ 1

"Общеизвестным" программированием является то, что x += y является эквивалентной сокращенной записью x = x + y. Пока x и y относятся к одному и тому же типу (например, оба являются int), вы можете считать эти два оператора эквивалентными.

Однако в Java x += y не идентичен x = x + y в целом.

Если x и y относятся к разным типам, поведение двух операторов различается из-за правил языка. Например, пусть есть x == 0 (int) и y == 1.1 (double):

    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'

+= выполняет неявное приведение, тогда как для + вам необходимо явным образом приводить второй операнд, иначе вы получите ошибку компилятора.

Цитата из Joshua Bloch Java Puzzlers:

(...) составные выражения присваивания автоматически приводят результат вычисления, которые они выполняют для типа переменной на их левая сторона. Если тип результата идентичен типу переменная, приведение не имеет никакого эффекта. Если, однако, тип результат шире, чем у переменной, соединение оператор присваивания выполняет тихое сужение примитива преобразование [JLS 5.1.3].

Ответ 2

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

и т.д.

Ответ 3

Это один из операторов присваивания . Он принимает значение x, добавляет к нему 0.1, а затем сохраняет результат (x + 0,1) обратно в x.

Итак:

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

Он функционально идентичен, но короче:

double x = 1.3;
x = x + 0.1;

ПРИМЕЧАНИЕ. Когда вы выполняете математику с плавающей запятой, вещи не всегда работают так, как вы думаете, они будут.

Ответ 4

devtop += Math.pow(x[i] - mean, 2); добавит результат операции Math.pow(x[i] - mean, 2) к переменной devtop.

Более простой пример:

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

Ответ 5

devtop += Math.pow(x[i] - mean, 2); добавляет Math.pow(x[i] - mean, 2) в devtop.

Ответ 6

В java тип по умолчанию чисел, таких как 2 или -2 (без дробного компонента), является int, и в отличие от c #, это не объект, и мы не можем сделать что-то вроде 2.tostring, как в c #, и тип по умолчанию чисел, например, 2.5 (с дробным компонентом) является двойным; Так что если вы напишите:

short s = 2;
s = s + 4;

вы получите ошибку компиляции, которую int нельзя преобразовать в short, если вы выполните что-то вроде ниже:

float f = 4.6;
f = f + 4.3;

вы получите две ошибки компиляции для установки двойного '4.6' для переменной с плавающей запятой в обеих строках, и ошибка первой строки логична, потому что float и double используют разные системы хранения чисел, и использование одной вместо другой может привести к потере данных ; Два приведенных примера могут быть изменены следующим образом:

s += 4
f += 4.3

которые оба имеют неявное приведение кода и не имеют ошибок компиляции; Еще один момент, заслуживающий рассмотрения, это то, что числа в диапазоне байтовых типов данных кэшируются в java, и, таким образом, числа от -128 до 127 имеют тип байта в java, поэтому в этом коде нет ошибок компиляции:

byte b = 127

но в этом действительно есть ошибка:

byte b = 128

потому что 128 - это int в Java; для длинных чисел мы рекомендуем использовать L после числа для переполнения целых чисел, например:

long l = 2134324235234235L

в java у нас нет перегрузки операторов, как c++, но + = перегружается только для String, а не для let скажем StringBuilder или StringBuffer, и мы можем использовать его вместо метода String 'concat', но, как мы знаем, String является неизменным, и это создаст другой объект и не изменит тот же объект, что и раньше:

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

Это хорошо;

Ответ 7

Вы можете взглянуть на байт-код, когда захотите понять, как работают Java-операторы. Вот если вы компилируете:

int x = 0;
x += 0.1;

байт-код будет доступен с помощью команды jdk javap -c [*.class] :( вы можете обратиться к спискам инструкций байт-кода Java для получения более подробной информации о байт-коде)

0: iconst_0 //  load the int value 0 onto the stack
1: istore_1 //  store int value into variable 1 (x)
2: iload_1 // load an int value from local variable 1 (x)
3: i2d // convert an int into a double (cast x to double)
4: ldc2_w        #2                  // double 0.1d -> push a constant value (0.1) from a constant pool onto the stack
7: dadd //  add two doubles (pops two doubles from stack, adds them, and pushes the answer onto stack)
8: d2i // convert a double to an int (pops a value from stack, casts it to int and pushes it onto stack)
9: istore_1 // store int value into variable 1 (x)

Теперь ясно, что java-компилятор увеличивает x на удвоение, а затем добавляет его с 0.1.
Наконец, это приводит к ответу на integer.
Есть один интересный факт, который я узнал, когда вы пишете:

byte b = 10;
b += 0.1;

компилятор приводит к удвоению b, добавляет его с помощью 0.1, приводит к результату double к integer и, наконец, приводит к byte, и это потому, что нет инструкции для приведения double до byte напрямую.
Вы можете проверить байт-код, если сомневаетесь :)