Cómo comprobar si un número es positivo en Java

Introducción

En este laboratorio, aprenderás cómo comprobar si un número es positivo en Java. Comenzaremos escribiendo un programa sencillo para comparar un número con cero utilizando declaraciones condicionales básicas.

Luego, extenderás este conocimiento para probar con tipos de datos enteros y de punto flotante (double), comprendiendo cómo manejar diferentes representaciones numéricas. Finalmente, exploraremos cómo manejar casos extremos, centrándonos específicamente en cómo identificar y manejar correctamente el caso en el que el número es cero.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java/BasicSyntaxGroup -.-> java/data_types("Data Types") java/BasicSyntaxGroup -.-> java/operators("Operators") java/BasicSyntaxGroup -.-> java/variables("Variables") java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/BasicSyntaxGroup -.-> java/output("Output") subgraph Lab Skills java/data_types -.-> lab-559968{{"Cómo comprobar si un número es positivo en Java"}} java/operators -.-> lab-559968{{"Cómo comprobar si un número es positivo en Java"}} java/variables -.-> lab-559968{{"Cómo comprobar si un número es positivo en Java"}} java/if_else -.-> lab-559968{{"Cómo comprobar si un número es positivo en Java"}} java/output -.-> lab-559968{{"Cómo comprobar si un número es positivo en Java"}} end

Comparar un número con cero

En este paso, escribiremos un sencillo programa en Java para comparar un número con cero. Esto te familiarizará con las declaraciones condicionales básicas en Java, específicamente la declaración if. Las declaraciones condicionales permiten que tu programa tome decisiones basadas en ciertas condiciones.

Primero, asegúrate de estar en el directorio correcto. Abre la Terminal en la parte inferior del WebIDE y escribe el siguiente comando, luego presiona Enter:
```
cd ~/project
```
Esto te asegura de que estás en el directorio ~/project donde crearemos nuestro archivo Java.
Ahora, creemos un nuevo archivo Java llamado CompareNumber.java. Puedes hacer esto haciendo clic derecho en el Explorador de archivos de la izquierda, seleccionando "Nuevo archivo" y escribiendo CompareNumber.java. Alternativamente, puedes usar la Terminal:
```
touch CompareNumber.java
```
Abre el archivo CompareNumber.java en el Editor de código haciendo clic en él en el Explorador de archivos.
Copia y pega el siguiente código Java en el 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.");
        }
    }
}
```
Veamos las partes nuevas de este código:
- int number = 10;: Esta línea declara una variable llamada number de tipo int (entero) y le asigna el valor 10. Las variables se utilizan para almacenar datos en tu programa.
- if (number > 0): Esta es una declaración if. Comprueba si la condición dentro de los paréntesis (number > 0) es verdadera. Si la condición es verdadera, se ejecutará el código dentro de las llaves {} que siguen.
- System.out.println("The number is positive.");: Esta línea solo se ejecutará si el number es mayor que 0.
Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, compila el programa Java utilizando el comando javac en la Terminal:
```
javac CompareNumber.java
```
Si no hay errores, se creará un archivo CompareNumber.class en el directorio ~/project.
Finalmente, ejecuta el programa compilado utilizando el comando java:
```
java CompareNumber
```
Dado que la variable number está establecida en 10 (que es mayor que 0), deberías ver la siguiente salida:
```
The number is positive.
```

Has escrito y ejecutado con éxito un programa Java que utiliza una declaración if para comparar un número con cero. En el siguiente paso, expandiremos este programa para manejar diferentes casos.

Prueba con enteros y números de punto flotante (double)

En el paso anterior, comparamos un número entero con cero. Java admite diferentes tipos de números, incluyendo enteros (números enteros) y números de punto flotante (números con decimales). En este paso, modificaremos nuestro programa para probar con tipos de datos enteros y de punto flotante (double) e introduciremos la declaración else para manejar el caso en el que el número no es positivo.

Abre el archivo CompareNumber.java en el editor del WebIDE si no está abierto.
Modifica el código para incluir un bloque else. Reemplaza el código existente con lo siguiente:
```
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.");
        }
    }
}
```
Esto es lo nuevo:
- int number = -5;: Cambiamos el valor de number a -5 para probar la condición else.
- else { ... }: El bloque else se ejecuta si la condición en la declaración if anterior es falsa. En este caso, si number > 0 es falso, se ejecutará el código dentro del bloque else.
Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado en la Terminal:
```
javac CompareNumber.java
```
Ejecuta el programa compilado:
```
java CompareNumber
```
Dado que number es -5, la condición if (-5 > 0) es falsa, por lo que se ejecutará el bloque else. Deberías ver la salida:
```
The number is not positive.
```

Ahora, probemos con un double (un número de punto flotante). Modifica el código nuevamente:

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.");
        }
    }
}

Cambiamos el tipo de variable a double y le asignamos un valor decimal.

Guarda el archivo.
Compila el programa:
```
javac CompareNumber.java
```
Ejecuta el programa:
```
java CompareNumber
```
Dado que decimalNumber es 3.14 (que es mayor que 0), la condición if será verdadera y deberías ver la salida:
```
The number is positive.
```

Ahora has visto cómo usar la declaración else y cómo funciona la comparación con tipos de datos enteros y de punto flotante (double). En el siguiente paso, manejaremos el caso específico en el que el número es exactamente cero.

Manejar casos extremos como el cero

En los pasos anteriores, manejamos números positivos y no positivos. Sin embargo, no hemos abordado específicamente el caso en el que el número es exactamente cero. En programación, manejar estos "casos extremos" (edge cases) es importante para garantizar que tu programa se comporte correctamente en todas las situaciones. En este paso, usaremos la declaración else if para agregar una comprobación específica para el cero.

Abre el archivo CompareNumber.java en el editor del WebIDE.
Modifica el código para incluir un bloque else if para comprobar si el número es cero. Reemplaza el código existente con lo siguiente:
```
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.");
        }
    }
}
```
Veamos los cambios:
- int number = 0;: Establecemos number en 0 para probar la nueva condición.
- else if (number == 0): Esta es una declaración else if. Se comprueba solo si la condición if anterior (number > 0) es falsa. La condición number == 0 comprueba si el valor de number es exactamente igual a 0. Ten en cuenta el doble signo igual (==) para la comparación, ya que un solo signo igual (=) se utiliza para la asignación.
- System.out.println("The number is zero.");: Esta línea se ejecutará si number es exactamente 0.
- El bloque else final ahora maneja específicamente el caso en el que el número no es positivo ni cero, lo que significa que debe ser negativo.
Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado en la Terminal:
```
javac CompareNumber.java
```
Ejecuta el programa compilado:
```
java CompareNumber
```
Dado que number es 0, la primera condición if (0 > 0) es falsa. La condición else if (0 == 0) es verdadera, por lo que se ejecutará su bloque. Deberías ver la salida:
```
The number is zero.
```

Ahora, probemos de nuevo con un número negativo. Cambia el valor de number a -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.");
        }
    }
}

Guarda el archivo.
Compila el programa:
```
javac CompareNumber.java
```
Ejecuta el programa:
```
java CompareNumber
```
Dado que number es -10, la condición if (-10 > 0) es falsa, y la condición else if (-10 == 0) también es falsa. Por lo tanto, se ejecutará el bloque else final, y deberías ver la salida:
```
The number is negative.
```

Ahora has utilizado con éxito las declaraciones if, else if y else para comparar un número con cero y determinar si es positivo, negativo o cero. Este es un patrón fundamental para tomar decisiones en tus programas Java.

Resumen

En este laboratorio (lab), comenzamos aprendiendo cómo configurar nuestro entorno de desarrollo navegando hasta el directorio correcto y creando un nuevo archivo Java. Luego, introdujimos el concepto fundamental de las declaraciones condicionales en Java utilizando la declaración if. Al escribir un programa sencillo, aprendimos cómo declarar una variable entera, asignarle un valor y usar el operador > dentro de una condición if para comprobar si el número es mayor que cero. Vimos cómo el bloque de código dentro de la declaración if se ejecuta solo cuando la condición es verdadera, lo que demuestra cómo imprimir un mensaje que indique que el número es positivo.