Cómo verificar si un número es divisible por otro en Java

Introducción

En este laboratorio, aprenderás cómo verificar si un número es divisible por otro en Java. Exploraremos el uso del operador módulo (%) para determinar la divisibilidad al comprobar si el residuo de una división es cero.

Practicarás el uso del operador módulo con diferentes números y divisores, y también aprenderás cómo manejar el caso especial de la división por cero para evitar errores en tus programas Java.

Utilizar el operador módulo para verificar la divisibilidad

En este paso, exploraremos cómo usar el operador módulo (%) en Java para verificar la divisibilidad. El operador módulo te da el residuo de una división. Si el residuo de una división es 0, significa que el número es perfectamente divisible por el divisor.

Vamos a crear un nuevo programa Java para demostrar esto.

Abre el directorio ~/project en el Explorador de Archivos de la izquierda.
Haz clic derecho en el espacio vacío dentro del directorio ~/project y selecciona "Nuevo Archivo".
Nombrar el nuevo archivo DivisibilityCheck.java.
Abre el archivo DivisibilityCheck.java en el Editor de Código.

Copia y pega el siguiente código en el editor:

public class DivisibilityCheck {
    public static void main(String[] args) {
        int number = 10;
        int divisor = 2;

        // Use the modulo operator to check for divisibility
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

        number = 11;
        divisor = 3;

        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }
    }
}

Veamos las nuevas partes:

int number = 10;: Esto declara una variable entera llamada number y le asigna el valor 10.
int divisor = 2;: Esto declara una variable entera llamada divisor y le asigna el valor 2.
number % divisor: Esta es la operación módulo. Calcula el residuo cuando number se divide por divisor.
if (number % divisor == 0): Esta es una declaración if. Verifica si el resultado de la operación módulo es igual a 0. Si lo es, se ejecuta el código dentro del bloque if.
else: Si la condición en la declaración if es falsa (el residuo no es 0), se ejecuta el código dentro del bloque else.

Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal en la parte inferior del WebIDE. Asegúrate de estar en el directorio ~/project. Si no lo estás, escribe cd ~/project y presiona Enter.
Compila el programa Java escribiendo el siguiente comando y presionando Enter:
```
javac DivisibilityCheck.java
```
Si no hay errores, no verás ninguna salida. Se creará un archivo DivisibilityCheck.class en el directorio ~/project.
Ejecuta el programa Java compilado escribiendo el siguiente comando y presionando Enter:
```
java DivisibilityCheck
```
Deberías ver la siguiente salida:
```
10 is divisible by 2
11 is not divisible by 3
```

Esta salida confirma que nuestro programa usó correctamente el operador módulo para verificar la divisibilidad.

Probar con diferentes divisores

En el paso anterior, verificamos la divisibilidad de 10 entre 2 y de 11 entre 3. Ahora, modifiquemos nuestro programa para probar con diferentes números y divisores y ver cómo se comporta el operador módulo.

Abre el archivo DivisibilityCheck.java en el editor del WebIDE si no está abierto.

Vamos a agregar algunos ejemplos más al método main. Agrega las siguientes líneas de código antes de la llave de cierre } del método main:


        System.out.println("\nTesting with different numbers:");

        number = 15;
        divisor = 5;
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

        number = 20;
        divisor = 7;
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

        number = 100;
        divisor = 10;
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

Hemos agregado tres nuevas comprobaciones con diferentes valores para number y divisor. La línea System.out.println("\nTesting with different numbers:"); simplemente agrega una línea en blanco y un encabezado para que la salida sea más clara.

Guarda el archivo DivisibilityCheck.java modificado (Ctrl+S o Cmd+S).
Abre la Terminal y asegúrate de estar en el directorio ~/project.
Compila el programa Java actualizado:
```
javac DivisibilityCheck.java
```
Nuevamente, si la compilación es exitosa, no verás ninguna salida.
Ejecuta el programa compilado para ver los resultados con los nuevos casos de prueba:
```
java DivisibilityCheck
```
Ahora deberías ver la salida del paso anterior, seguida de la salida de los nuevos casos de prueba:
```
10 is divisible by 2
11 is not divisible by 3

Testing with different numbers:
15 is divisible by 5
20 is not divisible by 7
100 is divisible by 10
```

Al agregar estos casos de prueba, puedes ver cómo el operador módulo identifica correctamente si un número es perfectamente divisible por otro número. Este es un concepto fundamental utilizado en muchas tareas de programación, como comprobar si un número es par o impar, o realizar acciones en intervalos regulares.

Manejar la división por cero

En matemáticas, la división entre cero está indefinida. En programación, intentar dividir entre cero (o realizar una operación módulo con cero como divisor) generalmente causará un error. Es importante manejar esta situación en tu código para evitar que tu programa se bloquee.

Modifiquemos nuestro programa DivisibilityCheck.java para incluir una comprobación de división entre cero.

Abre el archivo DivisibilityCheck.java en el editor del WebIDE.
Vamos a agregar un nuevo caso de prueba donde el divisor es 0. Agrega el siguiente código antes de la llave de cierre } del método main:
```
        System.out.println("\nTesting division by zero:");

        number = 10;
        divisor = 0;

        if (divisor == 0) {
            System.out.println("Error: Division by zero is not allowed.");
        } else if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }
```
Esto es lo que hemos agregado:
- if (divisor == 0): Esta es una nueva declaración if que verifica si la variable divisor es igual a 0.
- System.out.println("Error: Division by zero is not allowed.");: Si el divisor es 0, esta línea imprime un mensaje de error.
- else if (number % divisor == 0): Esta es una declaración else if. Se verifica solo si la primera condición if (divisor == 0) es falsa. Aquí es donde realizamos la comprobación módulo, pero solo si el divisor no es cero.
Guarda el archivo DivisibilityCheck.java modificado.
Abre la Terminal y asegúrate de estar en el directorio ~/project.
Compila el programa Java actualizado:
```
javac DivisibilityCheck.java
```

Ejecuta el programa compilado:

java DivisibilityCheck

Deberías ver la salida de los pasos anteriores, seguida de la salida para el caso de prueba de división entre cero:

10 is divisible by 2
11 is not divisible by 3

Testing with different numbers:
15 is divisible by 5
20 is not divisible by 7
100 is divisible by 10

Testing division by zero:
Error: Division by zero is not allowed.

Al agregar la comprobación if (divisor == 0), hemos hecho que nuestro programa sea más robusto al prevenir un posible error cuando el divisor es cero. Esto es un aspecto importante de la escritura de código confiable.

Resumen

En este laboratorio, aprendimos cómo verificar si un número es divisible por otro número en Java utilizando el operador módulo (%). Creamos un programa Java DivisibilityCheck.java y utilizamos la declaración if para verificar si el residuo de la división (number % divisor) es igual a 0. Si el residuo es 0, el número es divisible por el divisor. Demostramos esto con ejemplos en los que el número es divisible y en los que no lo es.