Краткий ответ

Составное присваивание автоматически приводит результат операции к типу левой части. Поэтому обновление переменной типа byte через составной оператор компилируется, хотя обычное присваивание результата арифметического выражения требует явного приведения.

Это приведение не защищает от потери данных: при выходе за диапазон byte результат будет усечён по правилам преобразования к этому типу.

Исторический контекст

Составные операторы присваивания предназначены для краткой записи типичной операции обновления значения. Язык одновременно сохранил тип переменной слева и разрешил не повторять явное приведение результата в каждом таком выражении.

Правило особенно заметно на малых целочисленных типах, потому что арифметика над byte, short и char обычно выполняется после числового продвижения к int.

Постановка проблемы

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

Составной оператор разрешает такую запись, но не проверяет, помещается ли результат в диапазон целевого типа. Ошибка проявится не на этапе компиляции, а как изменение значения во время выполнения.

Подробное решение

Для составного присваивания с левой частью типа T действует семантика, близкая к следующей: результат операции вычисляется, затем приводится к T и сохраняется обратно. Существенная дополнительная деталь — левая часть вычисляется только один раз, что важно для выражений с побочными эффектами.

byte value = 1;
value += 1;       // допустимо, результат снова byte

// value = value + 1; // ошибка компиляции: результат имеет тип int

value = 127;
value += 1;       // -128: переполнение при приведении к byte

В выражении value + 1 оба операнда участвуют в числовом продвижении, поэтому результат имеет тип int. В value += 1 результат после вычисления неявно приводится обратно к типу value.

Такое поведение удобно для локальных счётчиков и других операций, где переполнение допустимо или контролируется отдельно. Если потеря данных недопустима, безопаснее выполнять вычисление в более широком типе и явно проверять диапазон перед приведением.

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

Ситуация из практики

В низкоуровневом коде байтовый буфер обрабатывался счётчиком типа byte. Разработчик использовал составное присваивание, ожидая, что Java автоматически предотвратит выход за диапазон, но после достижения значения 127 счётчик стал отрицательным.

Рассматривались два варианта. Сохранить byte было экономно по памяти, но требовало ручной обработки переполнения; заменить счётчик на int было проще и безопаснее, хотя тип переставал напрямую отражать формат данных.

Выбрали int для счётчика, а byte оставили только для элементов буфера. Это устранило неожиданное переполнение и сделало условие завершения обработки очевидным.

Что кандидаты часто упускают

Всегда ли составное присваивание эквивалентно обычному присваиванию с явным приведением?

Почти по смыслу — да, но не полностью по вычислению. Составное присваивание вычисляет левую часть один раз, тогда как буквальная замена на обычное присваивание может вычислить её повторно. Поэтому при индексах массивов, вызовах методов или других побочных эффектах поведение может различаться.

Какой результат даст увеличение byte со значением 127 на единицу?

Результат станет -128. После арифметического продвижения вычисляется значение 128, затем оно приводится к byte, диапазон которого составляет от -128 до 127; двоичное представление результата интерпретируется как отрицательное число.

Почему присваивание константного арифметического выражения иногда ведёт себя иначе?

Для некоторых постоянных выражений Java допускает неявное сужающее преобразование, если вычисленное значение гарантированно представимо в целевом типе. Это отдельное правило для константных выражений и оно не распространяется на произвольное выражение с переменной, даже если фактическое значение переменной сейчас мало.