Почему int i = 1024 * 1024 * 1024 * 1024 компилируется без ошибок?

Предел intсоставляет от -2147483648 до 2147483647.

Если я введу

int i = 2147483648;

затем Eclipse предложит красное подчеркивание под «2147483648».

Но если я сделаю это:

int i = 1024 * 1024 * 1024 * 1024;

это будет компилироваться нормально.

public class Test {
    public static void main(String[] args) {        

        int i = 2147483648;                   // error
        int j = 1024 * 1024 * 1024 * 1024;    // no error

    }
}

Может быть, это основной вопрос в Java, но я понятия не имею, почему второй вариант не дает ошибок.

В этом утверждении нет ничего плохого; Вы просто умножаете 4 числа и присваиваете его целому числу, просто случается переполнение. Это отличается от присвоения одного литерала , который будет проверяться границами во время компиляции.

Это литерал вне пределов, который вызывает ошибку, а не присваивание :

System.out.println(2147483648);        // error
System.out.println(2147483647 + 1);    // no error

В противоположность этому, longлитерал будет компилироваться нормально:

System.out.println(2147483648L);       // no error

Следует отметить , что, по сути, результат будет по- прежнему вычисляется во время компиляции , потому что 1024 * 1024 * 1024 * 1024это выражение константы :

int i = 1024 * 1024 * 1024 * 1024;

будет выглядеть так:

   0: iconst_0      
   1: istore_1      

Обратите внимание, что result ( 0) просто загружается и сохраняется, и умножение не происходит.

Из JLS §3.10.1 (спасибо @ChrisK за то, что он поднял это в комментариях):

Это ошибка времени компиляции, если десятичный литерал типа intбольше, чем 2147483648(2 ³¹ ), или если десятичный литерал 2147483648появляется где-то, кроме как операнд унарного минусового оператора ( §15.15.4 ).

1024 * 1024 * 1024 * 1024и 2147483648не имеют одинаковое значение в Java.

На самом деле, 2147483648 даже не имеет значения (хотя и 2147483648Lесть) в Java. Компилятор буквально не знает, что это такое и как его использовать. Так что скулит.

1024является действительным int в Java, и действительное значение, intумноженное на другое действительное значение int, всегда является допустимым int. Даже если это не то значение, которое вы ожидаете интуитивно ожидать, потому что вычисления будут переполнены.

пример

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

public static void main(String[] args) {
    int a = 1024;
    int b = a * a * a * a;
}

Вы ожидаете, что это приведет к ошибке компиляции? Это становится немного более скользким теперь.
Что если мы поместим цикл с 3 итерациями и умножим на цикл?

Компилятору разрешено оптимизировать, но он не может изменить поведение программы, пока он это делает.

Некоторая информация о том, как на самом деле обрабатывается этот случай:

В Java и многих других языках целые числа будут состоять из фиксированного числа битов. Вычисления, которые не соответствуют данному количеству битов, будут переполнены ; вычисление в основном выполняется по модулю 2 ^ 32 в Java, после чего значение преобразуется обратно в подписанном целое.

Другие языки или API используют динамическое число битов ( BigIntegerв Java), вызывают исключение или устанавливают магическое значение, например not-a-number.

Я понятия не имею, почему второй вариант не дает ошибки.

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

Для Java одна или несколько вещей из этого списка не произошли, и поэтому у вас нет возможности. Я не знаю, какой из них; вам придется спросить Java-дизайнера.

Для C # все это произошло - около четырнадцати лет назад, и поэтому соответствующая программа на C # вызвала ошибку, начиная с C # 1.0.

В дополнение к ответу Аршаджи я хочу показать еще одну вещь:

Не присваивание вызывает ошибку, а просто использование литерала . Когда вы пытаетесь

long i = 2147483648;

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

Таким образом, операции с int-values ​​(включая присваивания) могут переполняться без ошибки компиляции (и без ошибки времени выполнения), но компилятор просто не может обработать эти слишком большие литералы.

A: Потому что это не ошибка.

Фон: умножение 1024 * 1024 * 1024 * 1024приведет к переполнению. Переполнение очень часто является ошибкой. В случае переполнения разные языки программирования ведут себя по-разному. Например, C и C ++ называют это «неопределенным поведением» для целых чисел со знаком, а поведение определяется целыми числами без знака (взять математический результат, сложить, UINT_MAX + 1если результат отрицательный, вычесть, UINT_MAX + 1если результат больше, чем UINT_MAX).

В случае Java, если результат операции со intзначениями не находится в допустимом диапазоне, концептуально Java добавляет или вычитает 2 ^ 32, пока результат не окажется в допустимом диапазоне. Так что утверждение абсолютно законно и не по ошибке. Это просто не дает результата, на который вы, возможно, надеялись.

Вы можете с уверенностью утверждать, полезно ли такое поведение, и должен ли компилятор предупреждать вас. Я бы лично сказал, что предупреждение было бы очень полезно, но ошибка была бы неправильной, так как это допустимая Java.