Как проверить, является ли число идеальным квадратом на Java

Введение

В этом практическом занятии (лабораторной работе) вы научитесь определять, является ли заданное целое число идеальным квадратом на Java. Мы рассмотрим использование метода Math.sqrt() для вычисления квадратного корня числа и затем проверим, является ли результат целым числом.

С помощью практических упражнений по программированию вы реализуете программу на Java, которая принимает ввод от пользователя, вычисляет квадратный корень и определяет, является ли исходное число идеальным квадратом. Мы также протестируем программу с различными входными данными, включая отрицательные числа и числа, которые не являются идеальными квадратами, чтобы обеспечить ее надежность.

Вычислить квадратный корень и проверить на целое число

На этом этапе мы напишем программу на Java для вычисления квадратного корня числа и определения, является ли исходное число идеальным квадратом. Идеальный квадрат - это целое число, которое является квадратом другого целого числа; другими словами, это произведение целого числа на само себя. Например, 9 - это идеальный квадрат, так как оно равно 3 * 3.

Мы будем использовать метод Math.sqrt(), предоставляемый Java, для вычисления квадратного корня. Этот метод возвращает значение типа double, которое может иметь десятичные знаки. Чтобы проверить, является ли исходное число идеальным квадратом, нам нужно проверить, является ли его квадратный корень целым числом.

Сначала создадим новый файл Java с именем SquareRootChecker.java в директории ~/project. Для этого можно кликнуть правой кнопкой мыши в проводнике файлов слева и выбрать "New File", а затем ввести SquareRootChecker.java.
Откройте файл SquareRootChecker.java в редакторе и вставьте следующий код:
```
import java.util.Scanner;

public class SquareRootChecker {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter an integer: ");
        int number = scanner.nextInt();

        if (number < 0) {
            System.out.println("Cannot calculate the square root of a negative number.");
        } else {
            double squareRoot = Math.sqrt(number);

            // Check if the square root is an integer
            if (squareRoot == Math.floor(squareRoot)) {
                System.out.println(number + " is a perfect square.");
            } else {
                System.out.println(number + " is not a perfect square.");
            }
        }

        scanner.close();
    }
}
```
Рассмотрим новые части этого кода:
- import java.util.Scanner;: Мы снова импортируем класс Scanner для чтения ввода пользователя.
- System.out.print("Enter an integer: ");: Это приглашает пользователя ввести число.
- int number = scanner.nextInt();: Это читает целое число, введенное пользователем, и сохраняет его в переменной number.
- if (number < 0): Это if-оператор, который проверяет, является ли введенное число отрицательным. Если это так, мы выводим сообщение об ошибке.
- double squareRoot = Math.sqrt(number);: Эта строка использует метод Math.sqrt() для вычисления квадратного корня числа number и сохраняет результат в переменной типа double с именем squareRoot.
- if (squareRoot == Math.floor(squareRoot)): Это основная логика для проверки, является ли квадратный корень целым числом. Math.floor(squareRoot) возвращает наибольшее целое число, меньшее или равное squareRoot. Если squareRoot - целое число, то squareRoot и Math.floor(squareRoot) будут равны.
- System.out.println(...): Эти строки выводят результат в зависимости от того, является ли число идеальным квадратом или нет.
Сохраните файл (Ctrl+S или Cmd+S).
Теперь скомпилируйте программу в терминале:
```
javac SquareRootChecker.java
```
Если нет ошибок, будет создан файл SquareRootChecker.class.
Запустите скомпилированную программу:
```
java SquareRootChecker
```
Программа попросит вас ввести целое число. Введите число, например, 9, и нажмите Enter. Вы должны увидеть вывод, указывающий, что 9 - это идеальный квадрат. Запустите программу еще раз и введите число, например, 10. Вы должны увидеть вывод, указывающий, что 10 не является идеальным квадратом.
```
Enter an integer: 9
9 is a perfect square.
```
```
Enter an integer: 10
10 is not a perfect square.
```

Вы успешно написали программу на Java, которая вычисляет квадратный корень и проверяет, является ли число идеальным квадратом!

Использование Math.sqrt() для проверки идеального квадрата

На этом этапе мы сосредоточимся на том, как работает метод Math.sqrt() и как мы использовали его на предыдущем этапе для определения, является ли число идеальным квадратом.

Метод Math.sqrt() является частью встроенного класса Math в Java, который предоставляет множество математических функций. Метод Math.sqrt(double a) принимает значение типа double a в качестве входных данных и возвращает его квадратный корень в виде значения типа double.

Например:

Math.sqrt(9.0) возвращает 3.0
Math.sqrt(10.0) возвращает приблизительно 3.1622776601683795
Math.sqrt(0.0) возвращает 0.0
Math.sqrt(-9.0) возвращает NaN (Not a Number - не число)

В нашей программе SquareRootChecker.java мы считываем целое число от пользователя, но метод Math.sqrt() ожидает значение типа double. Java автоматически преобразует целое число number в значение типа double, когда мы передаем его в метод Math.sqrt().

Ключ к проверке на идеальный квадрат заключается в сравнении вычисленного квадратного корня (double squareRoot) с его округленным вниз значением (Math.floor(squareRoot)).

Если squareRoot - целое число (например, 3.0), то Math.floor(squareRoot) также будет равным 3.0, и условие squareRoot == Math.floor(squareRoot) будет истинным.
Если squareRoot имеет дробную часть (например, 3.16...), то Math.floor(squareRoot) будет равным 3.0, и условие squareRoot == Math.floor(squareRoot) будет ложным.

Это простое сравнение позволяет нам эффективно проверить, было ли исходное целое число идеальным квадратом.

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

Убедитесь, что вы находитесь в директории ~/project в терминале.
Запустите скомпилированную программу еще раз:
```
java SquareRootChecker
```
Введите число 25 и нажмите Enter. Обратите внимание на вывод.
```
Enter an integer: 25
25 is a perfect square.
```
Запустите программу еще раз:
```
java SquareRootChecker
```
Введите число 15 и нажмите Enter. Обратите внимание на вывод.
```
Enter an integer: 15
15 is not a perfect square.
```

Запуская программу с разными входными данными, вы можете увидеть, как сравнение Math.sqrt() и Math.floor() правильно определяет идеальные квадраты.

Тестирование отрицательных и нецелых входных данных

На этом этапе мы протестируем нашу программу SquareRootChecker.java с использованием отрицательных чисел и рассмотрим, что произойдет, если пользователь введет что-то, что не является целым числом.

В написанном нами коде мы добавили проверку на отрицательные числа:

if (number < 0) {
    System.out.println("Cannot calculate the square root of a negative number.");
}

Этот if-оператор обрабатывает случай, когда пользователь вводит отрицательное целое число. Протестируем эту часть кода.

Убедитесь, что вы находитесь в директории ~/project в терминале.
Запустите скомпилированную программу:
```
java SquareRootChecker
```
Когда появится запрос на ввод, введите отрицательное число, например, -4, и нажмите Enter.
```
Enter an integer: -4
Cannot calculate the square root of a negative number.
```

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

Теперь рассмотрим, что произойдет, если пользователь введет данные, которые не являются целым числом, например, текст или десятичное число. Наша программа использует метод scanner.nextInt() для чтения ввода. Этот метод предназначен только для чтения целых значений. Если пользователь введет что-то, что не может быть преобразовано в целое число, возникнет исключение InputMismatchException, и программа аварийно завершит работу.

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

Пока просто посмотрим, что произойдет, когда вы введете нецелые данные.

Запустите скомпилированную программу еще раз:
```
java SquareRootChecker
```

Когда появится запрос на ввод, введите какой-то текст, например, hello, и нажмите Enter.

Enter an integer: hello
Exception in thread "main" java.util.InputMismatchException
    at java.base/java.util.Scanner.throwFor(Scanner.java:939)
    at java.base/java.util.Scanner.next(Scanner.java:1594)
    at java.base/java.util.Scanner.nextInt(Scanner.java:2258)
    at java.base/java.util.Scanner.nextInt(Scanner.java:2212)
    at SquareRootChecker.main(SquareRootChecker.java:9)

Вы увидите сообщение об ошибке, указывающее на InputMismatchException. Это происходит потому, что метод scanner.nextInt() ожидал целое число, но получил "hello".

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

Резюме

В этой лабораторной работе мы научились определять, является ли заданное целое число идеальным квадратом на Java. Мы использовали метод Math.sqrt() для вычисления квадратного корня из входного числа.

Основная логика заключалась в проверке, является ли вычисленный квадратный корень целым числом, путем сравнения его с округленным вниз значением с помощью метода Math.floor(). Мы также обрабатывали случай ввода отрицательных чисел, так как квадратные корни из них не являются вещественными числами. Этот процесс позволил нам эффективно определять идеальные квадраты.