почему JVM не ругается на деление на 0?

Спасибо, кажется разобрался. Получается что NaN для лонга это его максимальное значение - 9223372036854775807 И если мы это представляем как short то программа пытается уместить, перебирая диапазон до тех пор пока максимальное значение не закончится. И так совпало, что значение заканчивается на -1. Верно?

Прошу прощения, NaN - это 0 разделить на 0. А любое положительное число при делении на 0 даст + бесконечность (POSITIVE_INFINITY) POSITIVE_INFINITY обозначается последовательностью байт 0x7ff0000000000000, что для лонга соответствует значению 9223372036854775807. При преобразовании его в любой другой целочисленный тип получится -1.

А это вызвало ещё вопросов.

long d = (int) (f / c);
        System.out.println(d);                          //на выходе 2147483647
        System.out.println((int) 9223372036854775807L); //на выходе -1
long d = (long) (f / c);
        System.out.println(d);                          //на выходе 9223372036854775807

почему тогда так получается? В первом случае выдало максимальное значение int. Мы же в первых двух случаях подавали максимальное значение для long. Не понятно. Вроде, бы и short, и int меньше чем long, но для одного -1, а для другого максимальное число.

Там надо разбираться, как в каждом случае происходит преобразование байтовой последовательности

System.out.println(0x7ff0000000000000L); // 9218868437227405312
System.out.println((int)0x7ff0000000000000L); // 0
System.out.println((int)(double)0x7ff0000000000000L); // 2147483647
System.out.println((short)0x7ff0000000000000L); // 0
System.out.println((short)(double)0x7ff0000000000000L); // -1

Уже несколько дней пытаюсь разобраться в этом вопросе. Стало понятней, но не все. На stackoverflow не получил ответа, спрошу у вас тут. Хотел бы получить объяснение про преобразование бесконечности к целочисленным типам. Например:

double d = Double.POSITIVE_INFINITY;
System.out.println((int)d); // 2147483647
System.out.println((int)0x7ff0000000000000L); // 0
System.out.println((int)(double)0x7ff0000000000000L); // 2147483647

Я создаю переменную d типа double и присваиваю ей значение положительной бесконечности. Далее, я преобразовываю эту бесконечность к типу int и на выходе получаю значение 2147483647. Вопрос 1: почему дробная положительная бесконечность преобразовалась в максимальное возможное значение для int? Далее, среда разработки показывает, что POSITIVE_INFINITY это некое число в шестнадцатеричной системе счисления (0x7ff0000000000000L). На выходе мы получаем, что это число в int будет равно 0. Используя обычный калькулятор перевода чисел из одной системы в другую получим число (0x7ff0000000000000L) в двоичной системе - 111111111110000000000000000000000000000000000000000000000000000. Вопрос 2. Последние 32 бита равны 0, старшие биты откидываются и поэтому int равен 0? Вопрос 3. Почему Double.POSITIVE_INFINITY(0x7ff0000000000000L) имеет на конце литерал L? Это же не лонг? Вопрос 4. Почему, когда в 4 строчке кода я вывожу:

System.out.println((int)(double)0x7ff0000000000000L);

Результатом получается снова максимальное число для int? Как происходит в данном случае сужение типа?

POSITIVE_INFINITY в двоичном представлении выглядит как последовательность 111111111110000000000000000000000000000000000000000000000000000. Число 9218868437227405312 в двоичном представлении выглядит точно так же. (в HEX это будет 0x7ff0000000000000L - и это именно long, в int это число не влезет, тут 8 байт). Но это не значит, что POSITIVE_INFINITY и 9218868437227405312 - это одно и то же число. У double своя структура, часть байт в double выделены под мантиссу, часть - под экспоненту. (double)0x7ff0000000000000L и Double.longBitsToDouble(0x7ff0000000000000L) - это два разных числа (второе - POSITIVE_INFINITY, первое - нет). Про порядок приведения double к целочисленным типам можно почитать в документации.