Como Verificar se um Número é um Quadrado Perfeito em Java: Guia Prático

Introdução

Neste laboratório, você aprenderá como determinar se um inteiro dado é um quadrado perfeito em Java. Exploraremos o uso do método Math.sqrt() para calcular a raiz quadrada de um número e, em seguida, verificar se o resultado é um número inteiro.

Através de exercícios práticos de codificação, você implementará um programa Java que recebe a entrada do usuário, calcula a raiz quadrada e determina se o número original é um quadrado perfeito. Também testaremos o programa com várias entradas, incluindo números negativos e números que não são quadrados perfeitos, para garantir sua robustez.

Calcular Raiz Quadrada e Verificar Inteiro

Nesta etapa, escreveremos um programa Java para calcular a raiz quadrada de um número e determinar se o número original é um quadrado perfeito. Um quadrado perfeito é um inteiro que é o quadrado de um inteiro; em outras palavras, é o produto de um inteiro por ele mesmo. Por exemplo, 9 é um quadrado perfeito porque é 3 * 3.

Usaremos o método Math.sqrt() fornecido pelo Java para calcular a raiz quadrada. Este método retorna um valor double, que pode ter casas decimais. Para verificar se o número original é um quadrado perfeito, precisamos ver se sua raiz quadrada é um número inteiro.

Primeiro, vamos criar um novo arquivo Java chamado SquareRootChecker.java no seu diretório ~/project. Você pode fazer isso clicando com o botão direito no File Explorer à esquerda e selecionando "New File", em seguida, digitando SquareRootChecker.java.
Abra o arquivo SquareRootChecker.java no editor e cole o seguinte código:
```
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();
    }
}
```
Vamos analisar as novas partes deste código:
- import java.util.Scanner;: Importamos a classe Scanner novamente para ler a entrada do usuário.
- System.out.print("Enter an integer: ");: Isso solicita que o usuário insira um número.
- int number = scanner.nextInt();: Isso lê o inteiro inserido pelo usuário e o armazena na variável number.
- if (number < 0): Esta é uma instrução if que verifica se o número inserido é negativo. Se for, imprimimos uma mensagem de erro.
- double squareRoot = Math.sqrt(number);: Esta linha usa o método Math.sqrt() para calcular a raiz quadrada de number e armazena o resultado em uma variável double chamada squareRoot.
- if (squareRoot == Math.floor(squareRoot)): Esta é a lógica principal para verificar se a raiz quadrada é um inteiro. Math.floor(squareRoot) retorna o maior inteiro menor ou igual a squareRoot. Se squareRoot for um número inteiro, squareRoot e Math.floor(squareRoot) serão iguais.
- System.out.println(...): Estas linhas imprimem o resultado com base em se o número é um quadrado perfeito ou não.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, compile o programa no Terminal:
```
javac SquareRootChecker.java
```
Se não houver erros, um arquivo SquareRootChecker.class será criado.
Execute o programa compilado:
```
java SquareRootChecker
```
O programa solicitará que você insira um inteiro. Insira um número como 9 e pressione Enter. Você deverá ver a saída indicando que 9 é um quadrado perfeito. Execute o programa novamente e insira um número como 10. Você deverá ver a saída indicando que 10 não é um quadrado perfeito.
```
Enter an integer: 9
9 is a perfect square.
```
```
Enter an integer: 10
10 is not a perfect square.
```

Você escreveu com sucesso um programa Java que calcula a raiz quadrada e verifica se um número é um quadrado perfeito!

Usar Math.sqrt() para Quadrados Perfeitos

Nesta etapa, focaremos em entender como Math.sqrt() funciona e como o usamos na etapa anterior para determinar se um número é um quadrado perfeito.

O método Math.sqrt() faz parte da classe Math embutida do Java, que fornece muitas funções matemáticas. Math.sqrt(double a) recebe um valor double a como entrada e retorna sua raiz quadrada como um double.

Por exemplo:

Math.sqrt(9.0) retorna 3.0
Math.sqrt(10.0) retorna aproximadamente 3.1622776601683795
Math.sqrt(0.0) retorna 0.0
Math.sqrt(-9.0) retorna NaN (Not a Number - Não é um Número)

Em nosso programa SquareRootChecker.java, lemos um inteiro do usuário, mas Math.sqrt() espera um double. Java converte automaticamente o int number em um double quando o passamos para Math.sqrt().

A chave para verificar um quadrado perfeito reside em comparar a raiz quadrada calculada (double squareRoot) com seu valor de piso (Math.floor(squareRoot)).

Se squareRoot for um número inteiro (como 3.0), então Math.floor(squareRoot) também será 3.0, e a condição squareRoot == Math.floor(squareRoot) será verdadeira.
Se squareRoot tiver uma parte decimal (como 3.16...), então Math.floor(squareRoot) será 3.0, e a condição squareRoot == Math.floor(squareRoot) será falsa.

Esta comparação simples nos permite verificar efetivamente se o inteiro original era um quadrado perfeito.

Vamos executar o programa novamente algumas vezes para observar a saída para diferentes entradas e solidificar sua compreensão.

Certifique-se de estar no diretório ~/project no Terminal.
Execute o programa compilado novamente:
```
java SquareRootChecker
```
Insira o número 25 e pressione Enter. Observe a saída.
```
Enter an integer: 25
25 is a perfect square.
```
Execute o programa novamente:
```
java SquareRootChecker
```
Insira o número 15 e pressione Enter. Observe a saída.
```
Enter an integer: 15
15 is not a perfect square.
```

Ao executar o programa com diferentes entradas, você pode ver como a comparação Math.sqrt() e Math.floor() identifica corretamente os quadrados perfeitos.

Testar Entradas Negativas e Não Inteiras

Nesta etapa, testaremos nosso programa SquareRootChecker.java com números negativos e consideraremos o que acontece se o usuário inserir algo que não seja um inteiro.

No código que escrevemos, incluímos uma verificação para números negativos:

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

Esta instrução if lida com o caso em que o usuário insere um inteiro negativo. Vamos testar esta parte do código.

Certifique-se de estar no diretório ~/project no Terminal.
Execute o programa compilado:
```
java SquareRootChecker
```
Quando solicitado, insira um número negativo, por exemplo, -4, e pressione Enter.
```
Enter an integer: -4
Cannot calculate the square root of a negative number.
```
Como esperado, o programa identifica corretamente que não pode calcular a raiz quadrada de um número negativo e imprime a mensagem apropriada.

Agora, vamos considerar o que acontece se o usuário inserir uma entrada que não seja um inteiro, como texto ou um número decimal. Nosso programa usa scanner.nextInt() para ler a entrada. Este método foi projetado para ler apenas valores inteiros. Se o usuário inserir algo que não pode ser analisado como um inteiro, uma InputMismatchException ocorrerá, e o programa travará.

Lidar com esses erros de forma adequada é uma parte importante da escrita de programas robustos. Para este laboratório introdutório, não implementaremos o tratamento completo de erros para entrada não inteira, mas é importante estar ciente de que isso pode acontecer. Em laboratórios futuros, você aprenderá técnicas como blocos try-catch para lidar com exceções e tornar seus programas mais resilientes a entradas inesperadas do usuário.

Por enquanto, vamos apenas observar o que acontece quando você insere uma entrada não inteira.

Execute o programa compilado novamente:
```
java SquareRootChecker
```

Quando solicitado, insira algum texto, por exemplo, hello, e pressione 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)

Você verá uma mensagem de erro indicando uma InputMismatchException. Isso ocorre porque scanner.nextInt() esperava um inteiro, mas recebeu "hello".

Esta etapa destaca a importância de considerar diferentes tipos de entrada do usuário e como seu programa irá lidar com eles. Embora nosso programa atual seja simples, entender esses problemas potenciais é crucial para desenvolver aplicações mais complexas.

Resumo

Neste laboratório, aprendemos como determinar se um inteiro fornecido é um quadrado perfeito em Java. Utilizamos o método Math.sqrt() para calcular a raiz quadrada do número de entrada.

A lógica principal envolveu verificar se a raiz quadrada calculada é um número inteiro, comparando-a com seu valor de piso usando Math.floor(). Também tratamos o caso de números de entrada negativos, pois suas raízes quadradas não são números reais. Este processo nos permitiu identificar efetivamente os quadrados perfeitos.