До сегодняшнего дня я думал, что к примеру:
i += j;
Был просто ярлыком для:
i = i + j;
Но если мы попытаемся это сделать:
int i = 5;
long j = 8;
Потом я = я + Дж;
не будем обобщать, но я += Дж;
будет компилироваться нормально.
Это значит, что на самом деле я += Дж;
это что-то вроде этого ярлыка
я = (типа Я) (я + к)
?
Как всегда с этими вопросами, ПСБ держит ответ. В этом случае §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,
Но +=
составлена таким образом, что это типа кастинг. я=(тип 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 = <int>(<double>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 не мог'т быть удалены.