Cómo verificar si un número es negativo en Java

Introducción

En este laboratorio, aprenderás cómo verificar si un número es negativo en Java. Comenzaremos escribiendo un programa sencillo utilizando declaraciones condicionales para determinar si un número es menor que cero.

Luego, explorarás cómo aplicar esta comprobación a diferentes tipos de datos numéricos y aprenderás cómo incluir el cero en tu comprobación de números negativos, lo que te proporcionará una comprensión integral del manejo de valores negativos en Java.

Verificar si el número es menor que cero

En este paso, escribiremos un sencillo programa en Java para verificar si un número dado es menor que cero. Esto te familiarizará con las declaraciones condicionales básicas en Java.

Primero, asegúrate de estar en el directorio ~/project. Puedes usar el comando cd ~/project en la Terminal si es necesario.
Crea un nuevo archivo Java llamado NumberCheck.java en el directorio ~/project. Puedes hacer esto haciendo clic derecho en el Explorador de archivos de la izquierda, seleccionando "Nuevo archivo" y escribiendo NumberCheck.java.
Abre el archivo NumberCheck.java en el Editor de código y pega el siguiente código:
```
public class NumberCheck {
    public static void main(String[] args) {
        int number = -5; // Nuestro número a verificar

        if (number < 0) {
            System.out.println("The number is less than zero.");
        }
    }
}
```
Veamos las partes nuevas:
- int number = -5;: Esta línea declara una variable llamada number de tipo int (entero) y le asigna el valor -5. Las variables son como contenedores que almacenan datos.
- if (number < 0): Esta es una declaración if. Verifica si la condición dentro de los paréntesis (number < 0) es verdadera. Si la condición es verdadera, se ejecuta el código dentro de las llaves {}.
- System.out.println("The number is less than zero.");: Esta línea solo se ejecutará si el number es realmente menor que 0.
Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, compila el programa usando el comando javac en la Terminal:
```
javac NumberCheck.java
```
Si no hay errores, se creará un archivo NumberCheck.class en el directorio ~/project.
Ejecuta el programa compilado usando el comando java:
```
java NumberCheck
```
Deberías ver la siguiente salida:
```
The number is less than zero.
```
Esto confirma que nuestra declaración if identificó correctamente que el número -5 es menor que cero.

Probar con diferentes tipos numéricos

En este paso, exploraremos cómo se comporta nuestro programa con diferentes tipos de números, específicamente números positivos y el cero. Esto te ayudará a entender cómo funciona la declaración if cuando la condición es falsa.

Abre el archivo NumberCheck.java en el Editor de código.

Modifica el valor de la variable number a un número positivo, por ejemplo, 10. El código ahora debería verse así:

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

        if (number < 0) {
            System.out.println("The number is less than zero.");
        }
    }
}

Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado en la Terminal:
```
javac NumberCheck.java
```
Nuevamente, si la compilación es exitosa, no verás ninguna salida.
Ejecuta el programa compilado:
```
java NumberCheck
```
Esta vez, no deberías ver ninguna salida. Esto se debe a que la condición number < 0 (que es 10 < 0) es falsa, por lo que el código dentro del bloque if se omite.

Ahora, probemos con el cero. Modifica el valor de la variable number a 0:

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

        if (number < 0) {
            System.out.println("The number is less than zero.");
        }
    }
}

Guarda el archivo.
Compila el programa:
```
javac NumberCheck.java
```
Ejecuta el programa:
```
java NumberCheck
```
Nuevamente, no deberías ver ninguna salida. Esto se debe a que 0 < 0 también es falsa.

Este paso demuestra que el código dentro de la declaración if solo se ejecuta cuando la condición es estrictamente verdadera. En el siguiente paso, modificaremos la condición para incluir el cero en nuestra comprobación de números no positivos.

Incluir cero en la comprobación de números negativos

En el paso anterior, vimos que nuestro programa solo imprime el mensaje si el número es estrictamente menor que cero. A menudo, es posible que queramos incluir el cero cuando comprobamos números no positivos (números que son menores o iguales a cero). En este paso, modificaremos nuestra condición para lograr esto.

Abre el archivo NumberCheck.java en el Editor de código.

Modifica la condición en la declaración if de number < 0 a number <= 0. El operador <= significa "menor o igual a".

El código actualizado debería verse así:

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

        if (number <= 0) { // Condición modificada
            System.out.println("The number is less than or equal to zero."); // Mensaje actualizado
        }
    }
}

También actualizamos el mensaje dentro de la declaración println para que sea más preciso.

Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado en la Terminal:
```
javac NumberCheck.java
```
Ejecuta el programa compilado:
```
java NumberCheck
```
Esta vez, dado que number es 0 y la condición 0 <= 0 es verdadera, deberías ver la siguiente salida:
```
The number is less than or equal to zero.
```

Vamos a probar rápidamente con un número negativo de nuevo. Cambia el valor de number de nuevo a -5:

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

        if (number <= 0) { // Condición modificada
            System.out.println("The number is less than or equal to zero."); // Mensaje actualizado
        }
    }
}

Guarda el archivo.
Compila el programa:
```
javac NumberCheck.java
```
Ejecuta el programa:
```
java NumberCheck
```
Deberías ver la siguiente salida:
```
The number is less than or equal to zero.
```
Esto confirma que nuestra condición actualizada funciona tanto para números negativos como para el cero.

Ahora has utilizado con éxito el operador "menor o igual a" (<=) para incluir el cero en tu comprobación condicional. Esta es una necesidad común en la programación cuando se trabaja con rangos de números.

Resumen

En este laboratorio, aprendimos cómo verificar si un número es negativo en Java. Comenzamos escribiendo un programa básico de Java utilizando una declaración if para determinar si un entero es menor que cero. Esto implicó crear un archivo Java, escribir el código con una variable y una comprobación condicional, compilar el programa utilizando javac y ejecutarlo con java para observar la salida. Este primer paso introdujo el concepto fundamental de utilizar lógica condicional (declaraciones if) para evaluar condiciones numéricas en Java.