Como Verificar se um Número Está Dentro de um Intervalo em Java - Guia Prático

Introdução

Neste laboratório, você aprenderá como verificar se um número está dentro de um intervalo específico em Java. Abordaremos os conceitos fundamentais de definição de um intervalo numérico usando limites inferior e superior, utilizando operadores lógicos para realizar a verificação do intervalo e entendendo como incluir valores de limite em suas comparações de intervalo. Através de exercícios práticos, você obterá experiência prática na implementação dessas técnicas em código Java.

Definir Intervalo com Limites Inferior e Superior

Nesta etapa, aprenderemos como definir um intervalo numérico usando limites inferior e superior em Java. Entender como trabalhar com intervalos é um conceito fundamental em programação, permitindo-nos verificar se um valor está dentro de um conjunto específico de números.

Um intervalo é simplesmente um conjunto de números entre um ponto de partida (o limite inferior) e um ponto final (o limite superior). Por exemplo, o intervalo entre 1 e 10 inclui todos os números de 1 até 10.

Vamos criar um programa Java simples para definir e trabalhar com um intervalo.

Abra o arquivo HelloJava.java no editor WebIDE, caso ele ainda não esteja aberto. Modificaremos este arquivo para nosso novo programa.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
public class HelloJava {
    public static void main(String[] args) {
        // Define the lower and upper bounds of the range
        int lowerBound = 10;
        int upperBound = 50;

        // Print the defined range
        System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");
    }
}
```
Vamos analisar as novas partes deste código:
- int lowerBound = 10;: Esta linha declara uma variável inteira chamada lowerBound e atribui a ela o valor 10. Este é o nosso ponto de partida para o intervalo.
- int upperBound = 50;: Esta linha declara uma variável inteira chamada upperBound e atribui a ela o valor 50. Este é o nosso ponto final para o intervalo.
- System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");: Esta linha imprime uma mensagem no console mostrando o intervalo definido usando os valores de lowerBound e upperBound. O símbolo + é usado para combinar strings de texto e valores de variáveis.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, vamos compilar nosso programa modificado. Abra o Terminal na parte inferior do WebIDE e certifique-se de estar no diretório ~/project. Em seguida, execute o seguinte comando:
```
javac HelloJava.java
```
Se não houver erros, a compilação foi bem-sucedida.
Finalmente, vamos executar o programa para ver a saída. No Terminal, execute:
```
java HelloJava
```
Você deve ver a seguinte saída:
```
Defined Range: [10, 50]
```
Isso confirma que nosso programa definiu e imprimiu corretamente os limites inferior e superior do intervalo.

Na próxima etapa, aprenderemos como verificar se um número está dentro deste intervalo definido usando operadores lógicos.

Usar Operadores Lógicos para Verificação de Intervalo

Nesta etapa, aprenderemos como usar operadores lógicos em Java para verificar se um número está dentro do intervalo que definimos na etapa anterior. Operadores lógicos são usados para combinar ou modificar expressões booleanas (expressões que são verdadeiras ou falsas).

Para verificar se um número está dentro de um intervalo definido por um limite inferior e um limite superior, precisamos verificar duas condições:

O número é maior ou igual ao limite inferior?
O número é menor ou igual ao limite superior?

Ambas as condições devem ser verdadeiras para que o número esteja dentro do intervalo. Em Java, usamos o operador lógico AND (&&) para combinar essas duas condições.

Vamos modificar nosso programa HelloJava.java para incluir essa verificação de intervalo.

Abra o arquivo HelloJava.java no editor WebIDE.
Modifique o método main para incluir uma variável para o número a ser verificado e a lógica de verificação de intervalo. Substitua o conteúdo existente do método main pelo seguinte:
```
    public static void main(String[] args) {
        // Define the lower and upper bounds of the range
        int lowerBound = 10;
        int upperBound = 50;

        // Define the number to check
        int numberToCheck = 35;

        // Check if the number is within the range using logical operators
        boolean isInRange = (numberToCheck >= lowerBound) && (numberToCheck <= upperBound);

        // Print the result
        System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");
        System.out.println("Number to Check: " + numberToCheck);
        System.out.println("Is " + numberToCheck + " within the range? " + isInRange);
    }
```
Aqui está o que adicionamos:
- int numberToCheck = 35;: Esta linha declara uma variável inteira numberToCheck e atribui a ela o valor 35. Este é o número que queremos verificar em relação ao nosso intervalo.
- boolean isInRange = (numberToCheck >= lowerBound) && (numberToCheck <= upperBound);: Este é o núcleo da nossa verificação de intervalo.
  - numberToCheck >= lowerBound: Isso verifica se numberToCheck é maior ou igual a lowerBound.
  - numberToCheck <= upperBound: Isso verifica se numberToCheck é menor ou igual a upperBound.
  - &&: Este é o operador lógico AND. Ele retorna true somente se ambas as condições à sua esquerda e à sua direita forem true.
  - O resultado de toda essa expressão (true ou false) é armazenado em uma variável booleana chamada isInRange.
- As linhas System.out.println agora também imprimem o número que está sendo verificado e o resultado da verificação de intervalo.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac HelloJava.java
```
Execute o programa compilado:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Defined Range: [10, 50]
Number to Check: 35
Is 35 within the range? true
```
Como 35 está de fato entre 10 e 50 (inclusive), o programa produz corretamente true.

Tente alterar o valor de numberToCheck para algo fora do intervalo (por exemplo, 5 ou 60) e recompilar e executar o programa novamente para ver como a saída muda.

Incluir Valores Limite no Intervalo

Na etapa anterior, usamos os operadores >= (maior ou igual a) e <= (menor ou igual a) para verificar se um número está dentro de um intervalo. Esses operadores são cruciais porque incluem os valores de limite (os limites inferior e superior) na verificação do intervalo.

Por exemplo, se nosso intervalo for [10, 50], um número é considerado dentro do intervalo se for 10, 50 ou qualquer número entre 10 e 50. Se tivéssemos usado > (maior que) e < (menor que) em vez disso, o intervalo seria (10, 50), o que significa que 10 e 50 em si não seriam incluídos.

Vamos confirmar esse comportamento testando nosso programa com os valores de limite.

Abra o arquivo HelloJava.java no editor WebIDE.

Testaremos a verificação de intervalo com o limite inferior e o limite superior. Modifique o método main para testar tanto lowerBound quanto upperBound como numberToCheck.

public class HelloJava {
    public static void main(String[] args) {
        // Define the lower and upper bounds of the range
        int lowerBound = 10;
        int upperBound = 50;

        // Test with the lower bound
        int numberToCheck1 = lowerBound;
        boolean isInRange1 = (numberToCheck1 >= lowerBound) && (numberToCheck1 <= upperBound);
        System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");
        System.out.println("Number to Check: " + numberToCheck1);
        System.out.println("Is " + numberToCheck1 + " within the range? " + isInRange1);
        System.out.println("---"); // Separator for clarity

        // Test with the upper bound
        int numberToCheck2 = upperBound;
        boolean isInRange2 = (numberToCheck2 >= lowerBound) && (numberToCheck2 <= upperBound);
        System.out.println("Number to Check: " + numberToCheck2);
        System.out.println("Is " + numberToCheck2 + " within the range? " + isInRange2);
    }
}

Adicionamos um segundo caso de teste usando numberToCheck2 definido como upperBound.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac HelloJava.java
```
Execute o programa compilado:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Defined Range: [10, 50]
Number to Check: 10
Is 10 within the range? true
---
Number to Check: 50
Is 50 within the range? true
```
Como você pode ver, tanto 10 (o limite inferior) quanto 50 (o limite superior) são corretamente identificados como estando dentro do intervalo porque usamos os operadores >= e <=. Isso confirma que nossa verificação de intervalo inclui os valores de limite.

Entender se um intervalo inclui seus limites (inclusivo) ou os exclui (exclusivo) é importante ao definir condições em seus programas. Os operadores >= e <= criam um intervalo inclusivo.

Resumo

Neste laboratório, aprendemos como definir um intervalo numérico em Java, definindo limites inferior e superior usando variáveis inteiras. Modificamos um programa Java simples para declarar esses limites e imprimir o intervalo definido no console, entendendo como combinar texto e valores de variáveis para saída. Essa etapa fundamental é crucial para, subsequentemente, verificar se um número está dentro desse intervalo especificado.

Como Verificar se um Número Está Dentro de um Intervalo Específico em Java

Introdução

Definir Intervalo com Limites Inferior e Superior

Usar Operadores Lógicos para Verificação de Intervalo

Incluir Valores Limite no Intervalo

Resumo