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

Introdução

Neste laboratório, você aprenderá como verificar se um número é negativo em Java. Começaremos escrevendo um programa simples usando instruções condicionais para determinar se um número é menor que zero.

Em seguida, você explorará como aplicar essa verificação a diferentes tipos de dados numéricos e aprenderá como incluir zero em sua verificação de números negativos, fornecendo uma compreensão abrangente do tratamento de valores negativos em Java.

Verificar se o Número é Menor que Zero

Nesta etapa, escreveremos um programa Java simples para verificar se um determinado número é menor que zero. Isso o apresentará às instruções condicionais básicas em Java.

Primeiro, certifique-se de estar no diretório ~/project. Você pode usar o comando cd ~/project no Terminal, se necessário.
Crie um novo arquivo Java chamado NumberCheck.java no diretório ~/project. Você pode fazer isso clicando com o botão direito no Explorador de Arquivos à esquerda, selecionando "Novo Arquivo" e digitando NumberCheck.java.
Abra o arquivo NumberCheck.java no Editor de Código e cole o seguinte código:
```
public class NumberCheck {
    public static void main(String[] args) {
        int number = -5; // Nosso número para verificar

        if (number < 0) {
            System.out.println("O número é menor que zero.");
        }
    }
}
```
Vamos analisar as novas partes:
- int number = -5;: Esta linha declara uma variável chamada number do tipo int (inteiro) e atribui a ela o valor -5. Variáveis são como contêineres que armazenam dados.
- 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 {} é executado.
- System.out.println("O número é menor que zero.");: Esta linha só será executada se o number for realmente menor que 0.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, compile o programa usando o comando javac no Terminal:
```
javac NumberCheck.java
```
Se não houver erros, um arquivo NumberCheck.class será criado no diretório ~/project.
Execute o programa compilado usando o comando java:
```
java NumberCheck
```
Você deve ver a saída:
```
O número é menor que zero.
```
Isso confirma que nossa instrução if identificou corretamente que o número -5 é menor que zero.

Testar com Diferentes Tipos Numéricos

Nesta etapa, exploraremos como nosso programa se comporta com diferentes tipos de números, especificamente números positivos e zero. Isso o ajudará a entender como a instrução if funciona quando a condição é falsa.

Abra o arquivo NumberCheck.java no Editor de Código.

Modifique o valor da variável number para um número positivo, por exemplo, 10. O código agora deve ser assim:

public class NumberCheck {
    public static void main(String[] args) {
        int number = 10; // Nosso número para verificar

        if (number < 0) {
            System.out.println("O número é menor que zero.");
        }
    }
}

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac NumberCheck.java
```
Novamente, se a compilação for bem-sucedida, você não verá nenhuma saída.
Execute o programa compilado:
```
java NumberCheck
```
Desta vez, você não deve ver nenhuma saída. Isso ocorre porque a condição number < 0 (que é 10 < 0) é falsa, então o código dentro do bloco if é ignorado.

Agora, vamos testar com zero. Modifique o valor da variável number para 0:

public class NumberCheck {
    public static void main(String[] args) {
        int number = 0; // Nosso número para verificar

        if (number < 0) {
            System.out.println("O número é menor que zero.");
        }
    }
}

Salve o arquivo.
Compile o programa:
```
javac NumberCheck.java
```
Execute o programa:
```
java NumberCheck
```
Novamente, você não deve ver nenhuma saída. Isso ocorre porque 0 < 0 também é falso.

Esta etapa demonstra que o código dentro da instrução if só é executado quando a condição é estritamente verdadeira. Na próxima etapa, modificaremos a condição para incluir zero em nossa verificação de números não positivos.

Incluir Zero na Verificação de Negativo

Na etapa anterior, vimos que nosso programa só imprime a mensagem se o número for estritamente menor que zero. Frequentemente, podemos querer incluir zero ao verificar números não positivos (números que são menores ou iguais a zero). Nesta etapa, modificaremos nossa condição para atingir esse objetivo.

Abra o arquivo NumberCheck.java no Editor de Código.

Modifique a condição na instrução if de number < 0 para number <= 0. O operador <= significa "menor ou igual a".

O código atualizado deve ser assim:

public class NumberCheck {
    public static void main(String[] args) {
        int number = 0; // Nosso número para verificar

        if (number <= 0) { // Condição alterada
            System.out.println("O número é menor ou igual a zero."); // Mensagem atualizada
        }
    }
}

Também atualizamos a mensagem dentro da instrução println para ser mais precisa.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac NumberCheck.java
```
Execute o programa compilado:
```
java NumberCheck
```
Desta vez, como number é 0 e a condição 0 <= 0 é verdadeira, você deve ver a saída:
```
O número é menor ou igual a zero.
```

Vamos testar rapidamente com um número negativo novamente. Mude o valor de number de volta para -5:

public class NumberCheck {
    public static void main(String[] args) {
        int number = -5; // Nosso número para verificar

        if (number <= 0) { // Condição alterada
            System.out.println("O número é menor ou igual a zero."); // Mensagem atualizada
        }
    }
}

Salve o arquivo.
Compile o programa:
```
javac NumberCheck.java
```
Execute o programa:
```
java NumberCheck
```
Você deve ver a saída:
```
O número é menor ou igual a zero.
```
Isso confirma que nossa condição atualizada funciona tanto para números negativos quanto para zero.

Você agora usou com sucesso o operador "menor ou igual a" (<=) para incluir zero em sua verificação condicional. Este é um requisito comum em programação ao lidar com intervalos de números.

Resumo

Neste laboratório, aprendemos como verificar se um número é negativo em Java. Começamos escrevendo um programa Java básico usando uma instrução if para determinar se um inteiro é menor que zero. Isso envolveu a criação de um arquivo Java, a escrita do código com uma variável e uma verificação condicional, a compilação do programa usando javac e a execução com java para observar a saída. Esta etapa inicial introduziu o conceito fundamental de usar lógica condicional (instruções if) para avaliar condições numéricas em Java.