byte byteVar = 100 работает, но int intVar = 100L приводит к ошибке компиляции. Зачем?

Question

Целочисленные литералы могут быть присвоены байтовым или коротким переменным до тех пор, пока значение литерала находится в диапазоне byte / short .

Но когда длинный литерал присваивается int переменная, ошибка компиляции сообщается, даже если значение long literal находится в диапазоне int .

Что такое logi c, объясняющее это?

Пример,

Приведенная ниже строка успешно скомпилирована

byte byteVar =  100;   //works, here 100 is integer literal.

но

int intVar = 100L;   // fails, here 100L is long literal

приводит к ошибке времени компиляции.

Может кто-нибудь, пожалуйста, объясните лежащий в основе logi c это движет.

Answer 1

Фактическая причина немного сложнее, чем предполагают некоторые другие ответы.

JLS 5.2 утверждает следующее о преобразованиях, разрешенных в контексте назначения .

Кроме того, если выражение является постоянным выражением (§15.28) типа byte, short, char или int:

• Сужающее примитивное преобразование может использоваться, если переменная имеет тип byte, short или char, а значение константного выражения может быть представлено в типе переменной.

• Сужающее примитивное преобразование, за которым следует преобразование упаковки, может использоваться, если переменная имеет тип Byte, Short или Character, а значение константного выражения может быть представлено в тип byte, short или char соответственно.

Объявление / инициализация

byte byteVar =  100;  // OK

работает, потому что все предварительные условия удовлетворены:

• 100 - это постоянное выражение sion
• его тип int
• его значение находится в диапазоне byte; т.е. он представлен как byte
• , он назначается переменной byte.

Объявление / инициализация

byte byteVar =  100L;  // FAIL

не выполняется, потому что тип 100L - long, а не int.

Answer 2

logi c для

int intVar = 100L;

не компилируется просто «зачем вы говорите L явно, если хотите, чтобы это было int? Вероятно, где-то ошибка, но мы не делаем» не знаю, неправильный ли это тип или значение ».

Более интересная часть состоит в том, почему

byte byteVar = 100;

компилируется вместо того, чтобы требовать от вас писать что-то вроде 100b. И я считаю, что есть как минимум две причины:

1. правая часть может быть постоянным выражением, а не просто литералом: в

   byte byteVar = SOME_CONST + 3;
   

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

2. просто то, что C ++ не имеет его и Java унаследовал лот из C ++.

Answer 3

Формат байтов - это 8-битный целочисленный формат, который может принимать целочисленные значения со знаком в диапазоне от -128 до 127. Поскольку целочисленное значение 100 попадает в этот диапазон,

byte byteVar = 100;

компилируется; целочисленный литерал имеет допустимый масштаб для того, в чем вы пытаетесь его сохранить. https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html перечисляет значения по умолчанию для примитивных типов данных, а таблица показывает, что byte, short и int имеют одно и то же значение структура; целое число, с которым больше ничего не связано с литералом.

Причина, по которой int и 100L не работают, заключается в том, что суффикс L создает литерал long или Int64. int - это Int32, 32-битный формат целого числа со знаком дополнения до 2. Если указать, что значение 100 должно быть в формате 64-битного целого числа со знаком дополнения 2, оно не уместится в 32-битном формате без переполнения, поэтому компилятор не разрешает такое присвоение.

Answer 4

L означает 64-битный целочисленный примитив int.

int intVar = 100L;

Следующая строка не будет скомпилирована, поскольку вы пытаетесь поместить 64-битный длинный примитивный литерал в 32-битная переменная типа int. Это даст: // ПЛОХО - компилятор не работает - Невозможно разместить 64-битный long int примитив в 32-битной int переменной.