Почему Java + +, - =, * =, / = составные операторы присваивания не требуют приведения?

До сегодняшнего дня я думал что например

i += j;

Был просто ярлык для:

i = i + j;

Но если мы попробуем это:

int i = 5;
long j = 8;

Тогда i = i + j;не скомпилирует но i += j;скомпилирует нормально.

Значит ли это, что на самом деле i += j;это ярлык для чего-то подобного i = (type of i) (i + j)?

Как всегда с этими вопросами, JLS держит ответ. В этом случае §15.26.2 Составные операторы присваивания . Выписка:

Выражение присваивания соединения формы E1 op= E2эквивалентно E1 = (T)((E1) op (E2)), где Tэто тип E1, за исключением того, что E1вычисляется только один раз.

Пример, приведенный в §15.26.2

[...] следующий код правильный:

short x = 3;
x += 4.6;

и в результате x имеет значение 7, потому что оно эквивалентно:

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

Другими словами, ваше предположение верно.

Хорошим примером этого кастинга является использование * = или / =

byte b = 10;
b *= 5.7;
System.out.println(b); // prints 57

или

byte b = 100;
b /= 2.5;
System.out.println(b); // prints 40

или

char ch = '0';
ch *= 1.1;
System.out.println(ch); // prints '4'

или

char ch = 'A';
ch *= 1.5;
System.out.println(ch); // prints 'a'

Очень хороший вопрос Спецификация языка Java подтверждает ваше предложение.

Например, следующий код является правильным:

short x = 3;
x += 4.6;

и в результате x имеет значение 7, потому что оно эквивалентно:

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

Да,

в основном, когда мы пишем

i += l; 

компилятор преобразует это в

i = (int)(i + l);

Я только что проверил .classкод файла.

Действительно хорошая вещь, чтобы знать

вам нужно привести из longк int explicitlyв случае, если i = i + l он скомпилируется и даст правильный вывод. подобно

i = i + (int)l;

или

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

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

Проблема здесь заключается в приведении типов.

Когда вы добавляете int и long,

1. Объект int приводится к long, и оба добавляются, и вы получаете long объект.
2. но длинный объект не может быть неявно приведен к int. Итак, вы должны сделать это явно.

Но +=закодирован таким образом, что он выполняет приведение типов.i=(int)(i+m)

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

 byte -> short -> int -> long -> float -> double. 

То же самое не будет работать наоборот. Например, мы не можем автоматически преобразовать long в int, потому что первое требует больше памяти, чем второе, и, следовательно, информация может быть потеряна. Чтобы вызвать такое преобразование, мы должны выполнить явное преобразование.
Тип - Конверсия

Иногда такой вопрос можно задать на собеседовании.

Например, когда вы пишете:

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

нет автоматической типизации. В C ++ не будет ошибок при компиляции приведенного выше кода, но в Java вы получите что-то подобное Incompatible type exception.

Поэтому, чтобы избежать этого, вы должны написать свой код следующим образом:

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

Основное различие заключается в том a = a + b, что при не происходит типизирование, и поэтому компилятор злится на вас за отсутствие типизации. Но с тем a += b, что он действительно делает, является приведением типов bк типу, совместимому с a. Так что если вы делаете

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

Что вы на самом деле делаете:

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

Тонкий момент здесь ...

Существует неявное приведение типов для аргумента, i+jкогда jзначение double и iint. Java ВСЕГДА преобразует целое число в двойное, когда между ними есть операция.

Чтобы уточнить, i+=jгде iнаходится целое число и jдвойное, можно описать как

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

Смотрите: это описание неявного приведения

Вы можете типаж , jчтобы (int)в этом случае для ясности.

Спецификация языка Java определяет, E1 op= E2что она эквивалентна типу E1 = (T) ((E1) op (E2))where и оценивается один разTE1E1 .

Это технический ответ, но вам может быть интересно, почему это так. Что ж, давайте рассмотрим следующую программу.

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

Что печатает эта программа?

Вы догадались 3? Жаль, что эта программа не скомпилируется. Почему? Что ж, бывает так, что добавление байтов в Java определено как возвращающееint . Я полагаю, это произошло потому, что виртуальная машина Java не определяет байтовые операции для сохранения в байтовых кодах (в конце концов, их число ограничено), а использование целочисленных операций - это деталь реализации, представленная на языке.

Но если a = a + bне работает, это означало a += bбы, что никогда не будет работать для байтов, если это E1 += E2было определено как E1 = E1 + E2. Как показывает предыдущий пример, это действительно так. В качестве хака, заставляющего +=оператора работать для байтов и шортов, подразумевается неявное приведение. Это не так здорово, но во время работы над Java 1.0 основное внимание уделялось выпуску языка с самого начала. Теперь, из-за обратной совместимости, этот хак, введенный в Java 1.0, не может быть удален.