Почему Дон'т Ява'ы +=, -=, *=, /= составные операторы присваивания требуют литья?

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

состав, назначение выражения формы в <код>Е1&ампер;усилитель; nbsp;ОП=&ампер;усилитель; nbsp;Е2 на< код> есть эквивалент в <код>Е1&ампер;усилитель; nbsp;=&ампер;усилитель; nbsp;(Т)((Е1)&усилителя;усилитель; nbsp;ОП&усилителя;усилитель; nbsp;(Е2))</код>, где т - Тип "Е1", за исключением того, что " Е1 " вычисляется только один раз.

Пример привел из §15.26.2

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

короткая х = 3; х += 4.6;

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

короткая х = 3; х = (короткий)(х + 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 подтверждает ваше предложение.

например, следующий код корректен:

короткая х = 3; х += 4.6;

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

короткая х = 3; х = (короткий)(х + 4.6);

Да,

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

i += l; 

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

i = (int)(i + l);

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

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

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

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. Объект инт отлит в Long & другие добавляются, и вы получите длинный предмет.
2. но долго объект не может быть неявно преобразован в тип int. Таким образом, вы должны сделать это явно.

Но += составлена таким образом, что это типа кастинг. я=(тип int)(я+м)

В преобразованиях типа Java выполняются автоматически, если тип выражения в правой части операции присваивания можно смело продвигал к типу переменной в левой части присваивания. Таким образом, можно смело присвоить: в <предварительно> В байт -> короткого> внутреннее -> давно> поплавок -> двойной. </пред> То же самое не будет работать наоборот. Например, мы не может автоматически преобразовать Long в int, потому что первый требует больше памяти, чем второй и, следовательно, информация может быть потеряна. В силу такого преобразования мы должны выполнять явное преобразование. Тип - Преобразования

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

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

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

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

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

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

Главное отличие заключается в том, что с = А + Б, нет типажей, и поэтому компилятор злится на тебя за то, что не типажей. Но с + = б, что это'ов на самом деле типажей " Б "В тип, совместимый с "а". Так что если у вас

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);

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

Существует неявное приведение типа я+Дж, когда J в двойной и я имеет тип int. Ява **** всегда преобразует целое в двойное, когда идет операция между ними.

Для уточнения-я+=Дж, гдеяпредставляет собой целое число иJ` двойной можно охарактеризовать как

i = (i + j)

См.: [это описание неявное приведение][1]

Возможно, вы захотите продолжать относиться к J для `(инт) в данном случае для ясности.

[1]: https://www.cs.cmu.edu/~pattis/15-1ХХ/15-200/лекции/воу/лекция.сообщение: ImplicitConversion

Спецификацией языка Java определяет Е1 ОП= Е2 эквивалент Е1 = (Т) ((Е1) ОП (Е2)), где T - это тип " Е1 " и " Е1 " оценивается один раз.

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

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

Что это выводит программа?

Ты угадал 3? Жаль, Эта программа выиграла'т компиляции. Почему? Ну, бывает так, что кроме байтов в Java определяется, чтобы возвратить инт. Это, я считаю, что виртуальная машина Java не'т определить байтовые операции, чтобы сэкономить на байт-код (есть ограниченное количество тех, кто, в конце концов), вместо этого используя целочисленные операции является деталью реализации, выставленную на язык.

Но если А = А + Б Не'т работу, что будет означать а += б никогда не буду работать на байт, если это Е1 += Е2 был определен, чтобы быть Е1 = Е1 + Е2. Как показано в предыдущем примере, это было бы действительно так. Как рубить чтобы сделать работу оператора + = ` байты и шорты, есть неявное приведение участвует. Это's не то, что великий хак, но обратно на работу с Java 1.0, акцент был сделан на языке выпустили для начала. Теперь, из-за обратной совместимости, этот хак введены в Java 1.0 не мог'т быть удалены.