Como Verificar se um Número é Positivo em Java - Tutorial e Exemplos

Introdução

Neste laboratório, você aprenderá como verificar se um número é positivo em Java. Começaremos escrevendo um programa simples para comparar um número com zero usando instruções condicionais básicas.

Em seguida, você estenderá esse conhecimento para testar com os tipos de dados integer e double, compreendendo como lidar com diferentes representações numéricas. Finalmente, exploraremos como lidar com casos extremos (edge cases), focando especificamente em como identificar e gerenciar corretamente o caso em que o número é zero.

Comparar Número com Zero

Nesta etapa, escreveremos um programa Java simples para comparar um número com zero. Isso o apresentará às instruções condicionais básicas em Java, especificamente a instrução if. As instruções condicionais permitem que seu programa tome decisões com base em certas condições.

Primeiro, certifique-se de estar no diretório correto. Abra o Terminal na parte inferior do WebIDE e digite o seguinte comando, em seguida, pressione Enter:
```
cd ~/project
```
Isso garante que você esteja no diretório ~/project, onde criaremos nosso arquivo Java.
Agora, vamos criar um novo arquivo Java chamado CompareNumber.java. Você pode fazer isso clicando com o botão direito no File Explorer à esquerda, selecionando "New File" e digitando CompareNumber.java. Alternativamente, você pode usar o Terminal:
```
touch CompareNumber.java
```
Abra o arquivo CompareNumber.java no Code Editor clicando nele no File Explorer.
Copie e cole o seguinte código Java no editor:
```
public class CompareNumber {
    public static void main(String[] args) {
        int number = 10; // We will compare this number with zero

        if (number > 0) {
            System.out.println("The number is positive.");
        }
    }
}
```
Vamos analisar as novas partes deste código:
- int number = 10;: Esta linha declara uma variável chamada number do tipo int (inteiro) e atribui a ela o valor 10. Variáveis são usadas para armazenar dados em seu programa.
- if (number > 0): Esta é uma instrução if. Ela verifica se a condição dentro dos parênteses (number > 0) é verdadeira. Se a condição for verdadeira, o código dentro das chaves {} que se segue será executado.
- System.out.println("The number is positive.");: Esta linha só será executada se o number for maior que 0.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, compile o programa Java usando o comando javac no Terminal:
```
javac CompareNumber.java
```
Se não houver erros, um arquivo CompareNumber.class será criado no diretório ~/project.
Finalmente, execute o programa compilado usando o comando java:
```
java CompareNumber
```
Como a variável number está definida como 10 (que é maior que 0), você deverá ver a seguinte saída:
```
The number is positive.
```
Você escreveu e executou com sucesso um programa Java que usa uma instrução if para comparar um número com zero. Na próxima etapa, expandiremos este programa para lidar com diferentes casos.

Testar com Integer e Double

Na etapa anterior, comparamos um inteiro com zero. Java suporta diferentes tipos de números, incluindo inteiros (números inteiros) e números de ponto flutuante (números com casas decimais). Nesta etapa, modificaremos nosso programa para testar com os tipos de dados integer e double e introduziremos a instrução else para lidar com o caso em que o número não é positivo.

Abra o arquivo CompareNumber.java no editor WebIDE, caso ainda não esteja aberto.
Modifique o código para incluir um bloco else. Substitua o código existente pelo seguinte:
```
public class CompareNumber {
    public static void main(String[] args) {
        int number = -5; // Let's test with a negative integer

        if (number > 0) {
            System.out.println("The number is positive.");
        } else {
            System.out.println("The number is not positive.");
        }
    }
}
```
Aqui está o que é novo:
- int number = -5;: Mudamos o valor de number para -5 para testar a condição else.
- else { ... }: O bloco else é executado se a condição na instrução if anterior for falsa. Neste caso, se number > 0 for falso, o código dentro do bloco else será executado.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac CompareNumber.java
```
Execute o programa compilado:
```
java CompareNumber
```
Como number é -5, a condição if (-5 > 0) é falsa, então o bloco else será executado. Você deverá ver a saída:
```
The number is not positive.
```

Agora, vamos testar com um double (um número de ponto flutuante). Modifique o código novamente:

public class CompareNumber {
    public static void main(String[] args) {
        double decimalNumber = 3.14; // Test with a positive double

        if (decimalNumber > 0) {
            System.out.println("The number is positive.");
        } else {
            System.out.println("The number is not positive.");
        }
    }
}

Mudamos o tipo de variável para double e atribuímos a ela um valor decimal.

Salve o arquivo.
Compile o programa:
```
javac CompareNumber.java
```
Execute o programa:
```
java CompareNumber
```
Como decimalNumber é 3.14 (que é maior que 0), a condição if será verdadeira, e você deverá ver a saída:
```
The number is positive.
```
Você agora viu como usar a instrução else e como a comparação funciona com os tipos de dados integer e double. Na próxima etapa, lidaremos com o caso específico em que o número é exatamente zero.

Lidar com Casos Extremos como Zero

Nas etapas anteriores, lidamos com números positivos e não positivos. No entanto, não abordamos especificamente o caso em que o número é exatamente zero. Em programação, lidar com esses "casos extremos" (edge cases) é importante para garantir que seu programa se comporte corretamente em todas as situações. Nesta etapa, usaremos a instrução else if para adicionar uma verificação específica para zero.

Abra o arquivo CompareNumber.java no editor WebIDE.
Modifique o código para incluir um bloco else if para verificar se é zero. Substitua o código existente pelo seguinte:
```
public class CompareNumber {
    public static void main(String[] args) {
        int number = 0; // Let's test with zero

        if (number > 0) {
            System.out.println("The number is positive.");
        } else if (number == 0) {
            System.out.println("The number is zero.");
        } else {
            System.out.println("The number is negative.");
        }
    }
}
```
Vamos analisar as mudanças:
- int number = 0;: Definimos number como 0 para testar a nova condição.
- else if (number == 0): Esta é uma instrução else if. Ela é verificada somente se a condição if anterior (number > 0) for falsa. A condição number == 0 verifica se o valor de number é exatamente igual a 0. Observe o sinal de igual duplo (==) para comparação, pois um único sinal de igual (=) é usado para atribuição.
- System.out.println("The number is zero.");: Esta linha será executada se number for exatamente 0.
- O bloco else final agora lida especificamente com o caso em que o número não é nem positivo nem zero, o que significa que deve ser negativo.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac CompareNumber.java
```
Execute o programa compilado:
```
java CompareNumber
```
Como number é 0, a primeira condição if (0 > 0) é falsa. A condição else if (0 == 0) é verdadeira, então seu bloco será executado. Você deverá ver a saída:
```
The number is zero.
```

Agora, vamos testar com um número negativo novamente. Mude o valor de number para -10:

public class CompareNumber {
    public static void main(String[] args) {
        int number = -10; // Test with a negative number

        if (number > 0) {
            System.out.println("The number is positive.");
        } else if (number == 0) {
            System.out.println("The number is zero.");
        } else {
            System.out.println("The number is negative.");
        }
    }
}

Salve o arquivo.
Compile o programa:
```
javac CompareNumber.java
```
Execute o programa:
```
java CompareNumber
```
Como number é -10, a condição if (-10 > 0) é falsa, e a condição else if (-10 == 0) também é falsa. Portanto, o bloco else final será executado, e você deverá ver a saída:
```
The number is negative.
```
Você agora usou com sucesso as instruções if, else if e else para comparar um número com zero e determinar se ele é positivo, negativo ou zero. Este é um padrão fundamental para tomar decisões em seus programas Java.

Resumo

Neste laboratório, começamos aprendendo como configurar nosso ambiente de desenvolvimento, navegando até o diretório correto e criando um novo arquivo Java. Em seguida, introduzimos o conceito fundamental de instruções condicionais em Java usando a instrução if. Ao escrever um programa simples, aprendemos como declarar uma variável integer, atribuir um valor a ela e usar o operador > dentro de uma condição if para verificar se o número é maior que zero. Vimos como o bloco de código dentro da instrução if é executado somente quando a condição é verdadeira, demonstrando como imprimir uma mensagem indicando que o número é positivo.