Cómo verificar si un número está dentro de un rango específico en Java

Introducción

En este laboratorio, aprenderás cómo verificar si un número se encuentra dentro de un rango específico en Java. Cubriremos los conceptos fundamentales de definir un rango numérico utilizando límites inferior y superior, utilizar operadores lógicos para realizar la verificación de rango y comprender cómo incluir valores límite en tus comparaciones de rango. A través de ejercicios prácticos, adquirirás experiencia práctica en la implementación de estas técnicas en código Java.

Definir un rango con límites inferior y superior

En este paso, aprenderemos cómo definir un rango numérico utilizando límites inferior y superior en Java. Comprender cómo trabajar con rangos es un concepto fundamental en la programación, ya que nos permite verificar si un valor se encuentra dentro de un conjunto específico de números.

Un rango es simplemente un conjunto de números entre un punto de inicio (el límite inferior) y un punto final (el límite superior). Por ejemplo, el rango entre 1 y 10 incluye todos los números desde 1 hasta 10.

Vamos a crear un sencillo programa en Java para definir y trabajar con un rango.

Abre el archivo HelloJava.java en el editor WebIDE si no está abierto. Modificaremos este archivo para nuestro nuevo programa.
Reemplaza todo el contenido del archivo con el siguiente 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 + "]");
    }
}
```
Veamos las nuevas partes de este código:
- int lowerBound = 10;: Esta línea declara una variable entera llamada lowerBound y le asigna el valor 10. Este es nuestro punto de inicio para el rango.
- int upperBound = 50;: Esta línea declara una variable entera llamada upperBound y le asigna el valor 50. Este es nuestro punto final para el rango.
- System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");: Esta línea imprime un mensaje en la consola que muestra el rango definido utilizando los valores de lowerBound y upperBound. El símbolo + se utiliza para combinar cadenas de texto y valores de variables.
Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, vamos a compilar nuestro programa modificado. Abre la Terminal en la parte inferior del WebIDE y asegúrate de estar en el directorio ~/project. Luego, ejecuta el siguiente comando:
```
javac HelloJava.java
```
Si no hay errores, la compilación fue exitosa.
Finalmente, vamos a ejecutar el programa para ver la salida. En la Terminal, ejecuta:
```
java HelloJava
```
Deberías ver la siguiente salida:
```
Defined Range: [10, 50]
```
Esto confirma que nuestro programa definió e imprimió correctamente los límites inferior y superior del rango.

En el siguiente paso, aprenderemos cómo verificar si un número se encuentra dentro de este rango definido utilizando operadores lógicos.

Utilizar operadores lógicos para la verificación de rango

En este paso, aprenderemos cómo utilizar operadores lógicos en Java para verificar si un número se encuentra dentro del rango que definimos en el paso anterior. Los operadores lógicos se utilizan para combinar o modificar expresiones booleanas (expresiones que son verdaderas o falsas).

Para verificar si un número está dentro de un rango definido por un límite inferior y un límite superior, necesitamos verificar dos condiciones:

¿El número es mayor o igual que el límite inferior?
¿El número es menor o igual que el límite superior?

Ambas condiciones deben ser verdaderas para que el número esté dentro del rango. En Java, utilizamos el operador AND lógico (&&) para combinar estas dos condiciones.

Vamos a modificar nuestro programa HelloJava.java para incluir esta verificación de rango.

Abre el archivo HelloJava.java en el editor WebIDE.
Modifica el método main para incluir una variable para el número a verificar y la lógica de verificación de rango. Reemplaza el contenido existente del método main con lo siguiente:
```
    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);
    }
```
Esto es lo que hemos agregado:
- int numberToCheck = 35;: Esta línea declara una variable entera numberToCheck y le asigna el valor 35. Este es el número que queremos verificar en nuestro rango.
- boolean isInRange = (numberToCheck >= lowerBound) && (numberToCheck <= upperBound);: Esta es la parte central de nuestra verificación de rango.
  - numberToCheck >= lowerBound: Esto verifica si numberToCheck es mayor o igual que lowerBound.
  - numberToCheck <= upperBound: Esto verifica si numberToCheck es menor o igual que upperBound.
  - &&: Este es el operador AND lógico. Devuelve true solo si ambas condiciones a su izquierda y a su derecha son true.
  - El resultado de esta expresión completa (true o false) se almacena en una variable booleana llamada isInRange.
- Las líneas System.out.println ahora también imprimen el número que se está verificando y el resultado de la verificación de rango.
Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado en la Terminal:
```
javac HelloJava.java
```
Ejecuta el programa compilado:
```
java HelloJava
```
Deberías ver una salida similar a esta:
```
Defined Range: [10, 50]
Number to Check: 35
Is 35 within the range? true
```
Dado que 35 está efectivamente entre 10 y 50 (inclusive), el programa muestra correctamente true.

Intenta cambiar el valor de numberToCheck a algo fuera del rango (por ejemplo, 5 o 60) y vuelve a compilar y ejecutar el programa para ver cómo cambia la salida.

Incluir valores límite en el rango

En el paso anterior, utilizamos los operadores >= (mayor o igual que) y <= (menor o igual que) para verificar si un número está dentro de un rango. Estos operadores son cruciales porque incluyen los valores límite (los límites inferior y superior) en la verificación del rango.

Por ejemplo, si nuestro rango es [10, 50], un número se considera dentro del rango si es 10, 50 o cualquier número entre 10 y 50. Si hubiéramos utilizado > (mayor que) y < (menor que) en lugar de eso, el rango sería (10, 50), lo que significa que 10 y 50 en sí mismos no estarían incluidos.

Vamos a confirmar este comportamiento probando nuestro programa con los valores límite.

Abre el archivo HelloJava.java en el editor WebIDE.

Vamos a probar la verificación de rango con el límite inferior y el límite superior. Modifica el método main para probar tanto lowerBound como 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);
    }
}

Hemos agregado un segundo caso de prueba utilizando numberToCheck2 establecido en upperBound.

Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado en la Terminal:
```
javac HelloJava.java
```
Ejecuta el programa compilado:
```
java HelloJava
```
Deberías ver una salida similar 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 puedes ver, tanto 10 (el límite inferior) como 50 (el límite superior) se identifican correctamente como estando dentro del rango porque utilizamos los operadores >= y <=. Esto confirma que nuestra verificación de rango incluye los valores límite.

Comprender si un rango incluye sus límites (inclusivo) o los excluye (exclusivo) es importante al definir condiciones en tus programas. Los operadores >= y <= crean un rango inclusivo.

Resumen

En este laboratorio (lab), aprendimos cómo definir un rango numérico en Java estableciendo límites inferior y superior utilizando variables enteras. Modificamos un programa simple de Java para declarar estos límites e imprimir el rango definido en la consola, comprendiendo cómo combinar texto y valores de variables para la salida. Este paso fundamental es crucial para luego verificar si un número se encuentra dentro de este rango especificado.