Почему использование целочисленных переменных выдает исключение?

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

Интегральные типы ( JLS 4.2.1 ) категорически отличаются от типов с плавающей запятой ( JLS 4.2.3 ). Могут быть сходства в поведении и действиях, но есть также характерные отличия, так что их смешение может привести ко многим ловушкам.

Различие в поведении при делении на ноль - лишь одно из этих различий. Таким образом, краткий ответ заключается в том, что Java ведет себя так, потому что так говорит язык.

Целочисленные значения и значения с плавающей запятой

Значения целочисленных типов являются целыми числами в следующих диапазонах:

• байт : от -128 до 127 включительно, то есть [- 2 7 , 2 7 -1]
• короткий : от -32768 до 32767 включительно, то есть [- 2 15 , 2 15 -1]
• int : от -2147483648 до 2147483647 включительно, т.е. [- 2 31 , 2 31 -1]
• длинный : с - От 9223372036854775808 до 9223372036854775807 включительно, т.е. [- 2 63 , 2 63 -1]
• символ , с '\ u0000' на '\ uffff ' включительно, то есть от 0 до 65535 , то есть [0, 2 16 -1]

Плавающий -точечные типы - это float и double , которые концептуально связаны с 32-битным форматом одинарной точности и 64-битным форматом двойной точности значениями IEEE 754 и операции.

Их значения упорядочены следующим образом, от наименьшего к наибольшему:

• отрицательная бесконечность,
• отрицательные конечные ненулевые значения,
• положительный и отрицательный ноль (т. Е. 0,0 == -0,0 ) ,
• положительные конечные ненулевые значения и
• положительная бесконечность.

Кроме того, существуют специальные значения Not-a-Number ( NaN ), которые являются неупорядоченными . Это означает, что если один (или оба!) Операнда - NaN :

• числовые операторы сравнения <, <= , > , и > = return false
• оператор числового равенства == возвращает false
• оператор числового неравенства ! = возвращает true

В частности, x! = X равно true тогда и только тогда, когда x равно NaN .

Например, double , бесконечности и NaN могут упоминаться как:

• Double.POSITIVE_INFINITY
• Double.NEGATIVE_INFINITY
• Double.NaN , тестируется вспомогательным методом логическое isNaN (double)

Ситуация аналогична float и Float .

Вкл, когда могут возникать исключения

Числовые операции могут вызывать исключение только в следующих случаях:

1. NullPointerException , если распаковка преобразования ссылки null требуется
2. ArithmeticException , если правая часть равна нулю для целочисленных операций деления / остатка
3. OutOfMemoryError , если требуется преобразование упаковки и не хватает памяти

Они упорядочены по важности с точки зрения того, что они являются обычным источником подводных камней. Вообще говоря:

• Будьте особенно осторожны с типами блоков, как и все другие ссылочные типы, они могут быть null
• Будьте особенно осторожны с правой частью операций целочисленного деления / остатка
• Арифметика переполнение / недостаточное заполнение НЕ вызывает исключение
• Потеря точности НЕ вызывает исключение
• Математически неопределенная операция с плавающей запятой ДЕЙСТВУЕТ НЕ вызывает исключение

При делении на ноль

Для целочисленной операции:

• Операции деления и остатка генерируют ArithmeticException , если правая сторона равно нулю

Для операции с плавающей запятой :

• Если левый операнд равен NaN или 0 , результат будет NaN .
• Если операция деление , она переполняется, и результатом является бесконечность со знаком
• Если операция представляет собой остаток , результатом является NaN

Общее правило для всех операций с плавающей запятой выглядит следующим образом:

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

Приложение

Есть еще много вопросов, не охваченных этим уже длинным ответом, но читателям рекомендуется просматривать связанные вопросы и ссылочные материалы.

Связанные вопросы

• Что означают эти три специальных значения с плавающей запятой: положительная бесконечность, отрицательная бесконечность, NaN?
• Что означает NaN в Java?
• Когда Java может создавать NaN (с конкретным вопросом кода)
• Почему (360/24) / 60 = 0… в Java (различать операции с целыми числами и с плавающей запятой!)
• Почему null = = 0 вызывает исключение NullPointerException в Java? (остерегайтесь опасности упакованных примитивов!)
• Является ли 1/0 допустимым выражением Java? (абсолютно !!!)

Это потому, что целочисленная арифметика всегда оборачивает свой результат, за исключением случая (Деление / остаток на ноль).
В случае с плавающей запятой, когда происходит переполнение или потеря значимости, упаковка переходит в 0, бесконечность или NaN.
Во время переполнения дает бесконечность, а во время потери значимости - 0.
Опять же, есть положительное и отрицательное переполнение / недостаток.
Попробуйте:

float a = -1000;
float b = a/0;
System.out.println("b=" +b);

Это дает отрицательное переполнение

Выходные данные

b = -Infinity

Аналогично положительное отрицательное переполнение приведет к 0 и отрицательное отрицательное переполнение в -0.
Некоторые операции могут также привести к возврату NaN (не числа) с помощью float / double.
Например:

float a = -1000;
double b = Math.sqrt(a);
System.out.println("b=" +b);

Вывод

b = NaN

Это стандарт программирования и математики для представления / нулевыми значениями. float поддерживает представление таких значений в JAVA. Тип данных int (целое число) не может представлять то же самое в JAVA.

Проверить:

http://en.wikipedia.org/wiki/Division_by_zero

http://www.math.utah.edu/~pa/math/0by0.html

Потому что числа с плавающей запятой на самом деле имеют представление для «числа», которое вы пытаетесь вычислить. Так что он этим пользуется. Целое число не имеет такого представления.

Java (в основном) следует IEEE754 в части поддержки операций с плавающей запятой, подробнее см. здесь .