Ответ на вопрос про перевод секунд в микросекунды:
Правильный ответ тут будет 705032704 из-за переполнения int.
При умножении двух целочисленных значений Java выполняет умножение с использованием типа int. Если результат этого умножения превышает максимальное значение, которое может храниться в int (которое составляет 2,147,483,647), происходит переполнение, что приводит к неправильному поведению.

Чтобы избежать этой проблемы при работе с большими числами, можно убедиться, что умножение выполняется с использованием типа long, добавив суффикс L к числу, на которое вы умножаете (в данном случае 1_000_000L). Это повысит уровень операции умножения до long, который имеет гораздо большее максимальное значение (до 9,223,372,036,854,775,807).

Вот исправленная строка кода:
long microseconds = seconds * 1_000_000L;

Что напечатает код?

Разъяснение вопроса про get/set name:
В коде метод main создает экземпляр класса B, устанавливает значение имени с помощью метода setName, а затем выводит значение имени с помощью метода getName. Однако выводится null, и это может быть непонятным на первый взгляд. Давайте разберемся в чем дело.

Класс A содержит поле name, которое является закрытым (private) и имеет геттер getName, который возвращает значение этого поля.
Класс B наследуется от класса A, но в нем есть собственное закрытое поле name и метод setName, который устанавливает значение этого поля.

Когда вы вызываете b.setName("name");, вы устанавливаете значение локального поля name в классе B, а не в классе A. Поэтому поле name в классе A по-прежнему остается null.

Когда вызывается System.out.println(b.getName());, этот метод берёт значение поля name из класса A, которое не было изменено, и таким образом возвращает null.

Что напечатает код?

Ответ на вопрос про Integer.MIN_VALUE/-Integer.MIN_VALUE:
Выражение System.out.println(Integer.MIN_VALUE == -Integer.MIN_VALUE); выводит true.
Давайте поймем почему так:
Integer.MIN_VALUE — это константа в Java, представляющая наименьшее возможное значение для типа int. Для 32-битного целочисленного типа это значение равно -2,147,483,648 (или −(2^31)).

Когда мы берем отрицательное значение от Integer.MIN_VALUE, мы вычисляем:
-Integer.MIN_VALUE = -(-2,147,483,648) = 2,147,483,648
Однако 2,147,483,648 не может быть представлено в типе int, так как максимальное значение для int — это 2,147,483,647 (или 2^31 - 1). Поэтому при попытке установить такое значение происходит переполнение.

При преобразовании 2,147,483,648 в тип int происходит переполнение. Оно «оборачивается» назад по кругу и становится равным Integer.MIN_VALUE, то есть -2,147,483,648.

Есть ли проблемы в этом коде?

Ответ на вопрос про Math.abs:

Когда вы вызываете Math.abs(Integer.MIN_VALUE) в Java, результатом будет Integer.MIN_VALUE, и вы получите отрицательное значение. Давайте разберемся, почему так происходит.

Метод Math.abs() возвращает абсолютное значение числа. То есть он возвращает положительное значение, если число отрицательное, и само число, если оно положительное.

Integer.MIN_VALUE представляет собой наименьшее возможное значение для типа int в Java, которое равно -2,147,483,648 (или −(2^31)).

Когда вы вызываете Math.abs(-2,147,483,648), метод пытается вернуть положительное значение этого числа. Однако в диапазоне int не существует представления для 2,147,483,648, так как максимальное положительное значение int — это 2,147,483,647 (или 2^31 - 1).
Следовательно, попытка преобразовать Integer.MIN_VALUE в положительное значение приводит к переполнению.

По сути, когда Math.abs() пытается вернуть -(-2,147,483,648), это значение не может быть представлено в типе int, и в результате вы получите Integer.MIN_VALUE, а не ожидаемое положительное число.

Как вариант решения можно использовать Math.absExact, он в этом случае кидает ArithmeticError.
Так же обратите внимание на метод Math.floorMod как замену для Math.abs() % intVal

Ответ на вопрос про количество примитивных типов в java:

В Java существует восемь примитивных типов данных:

byte - 8-битное целое число.
short - 16-битное целое число.
int - 32-битное целое число.
long - 64-битное целое число.
float - 32-битное число с плавающей точкой.
double - 64-битное число с плавающей точкой.
char - 16-битный символ (представляет символ в кодировке UTF-16).
boolean - логический тип (может принимать значения true или false).

Правильно ли реализован метод?

Проблемы метода isOdd:
Метод будет правильно работать для положительных нечетных чисел, но он не будет правильно обрабатывать отрицательные нечетные числа. В частности, для отрицательных нечетных чисел, остаток от деления на 2 будет -1, что не соответствует условию. Например:
Для value = -3, возвращаемое значение будет равно:
-3 % 2 == -1 // это не то, что мы ожидаем, метод вернет false

Чтобы метод корректно определял нечетность для всех целых чисел (как положительных, так и отрицательных), вы можете использовать такую реализацию:

public boolean isOdd(int value) {
return value % 2 != 0;
}

Правильно ли работает метод?

Пояснение к to0_100Range():
Тут неправильное использование Math.min и Math.max: используется Math.max(value, 100), чтобы ограничить значение, но при этом вызывается Math.min(0, ...).
Это означает, что если value не меньше 100, то после выполнения этой операции value будет всегда 0, так как Math.min(0, ...) вернет 0 независимо от второго аргумента, если он больше 0.
Ожидаемое поведение - предполагается, что надо ограничить value в диапазоне от 0 до 100, включая крайние значения. Однако текущий код этого не делает. На самом деле, после выполнения этой строки:

Если value меньше 100, но больше 0, то ваше значение будет 0.
Если value больше 100, то оно останется 0 из-за Math.min.
Корректное решение:
Для ограничения значения value в диапазоне от 0 до 100, вы можете воспользоваться следующим кодом:
value = Math.max(0, Math.min(value, 100));

Что напечатает код?

Ответ на вопрос про -1 * 0.0 :
Когда вы выполняете выражение -1 * 0.0 в Java, результат будет -0.0. Давайте разберем, почему это происходит.

В математике любое число, умноженное на 0, всегда дает 0. Однако в языке программирования, таком как Java, 0 может быть представлен как 0.0 (положительный ноль с плавающей точкой) и -0.0 (отрицательный ноль с плавающей точкой). Обратите внимание, что это не просто разные представления одного и того же числа — они могут повлиять на поведение программ, которые используют их.

В данном случае 0.0 — это значение с плавающей точкой, и операция умножения с -1 (который является целым числом) автоматически приводит -1 к типу double для выполнения операции. Таким образом, -1 * 0.0 выполняется как -1.0 * 0.0.

Когда вы умножаете -1.0 * 0.0, результатом будет -0.0. В Java, значение -0.0 действительно существует и может быть использовано, например, в сравнениях или в других математических операциях.