Operadores aritméticos en programación

🔢 ¿Qué son los operadores aritméticos?

Los operadores aritméticos son símbolos que permiten realizar las operaciones matemáticas fundamentales sobre datos numéricos dentro de un programa: suma, resta, multiplicación, división y cálculo del resto. Junto con los operadores de asignación, son los primeros que cualquier programador aprende a utilizar y constituyen la base de todo cálculo computacional.

En Java —y en la mayoría de los lenguajes de programación— los operadores aritméticos se dividen en dos grandes grupos según el número de operandos que requieren:

➕ Operadores aritméticos unarios

Los operadores unarios se aplican a un solo operando. En Java existen cuatro operadores aritméticos unarios:

🔹 El operador de signo negativo

El operador - cuando se antepone a una expresión devuelve su valor con el signo cambiado. Si el operando ya es negativo, el resultado es positivo:

int a = 4;
int b = -a;           // b vale -4
int c = -b;           // c vale 4 (doble negación)
int d = -(-10);       // d vale 10

🧮 Operadores aritméticos binarios

Los operadores binarios trabajan con dos operandos y producen un resultado numérico. Son los más utilizados en cualquier programa:

▶️ Ejemplo práctico con todos los operadores

public class OperadoresBinarios {
    public static void main(String[] args) {

        int a = 17;
        int b = 5;

        System.out.println("Suma:           " + (a + b));    // 22
        System.out.println("Resta:          " + (a - b));    // 12
        System.out.println("Multiplicación: " + (a * b));    // 85
        System.out.println("División entera: " + (a / b));   // 3
        System.out.println("Módulo (resto):  " + (a % b));   // 2
    }
}

➗ División entera vs. división real

Uno de los aspectos que más confusión genera entre principiantes es que el operador / se comporta de forma distinta según el tipo de los operandos:

▶️ Comparación práctica

public class DivisionEntreaYReal {
    public static void main(String[] args) {

        int a = 7, b = 2;

        // División entera: ambos operandos son int
        System.out.println("7 / 2          = " + (a / b));           // 3

        // División real: al menos un operando es double
        System.out.println("7.0 / 2        = " + (7.0 / b));          // 3.5

        // Forzar división real con casting
        System.out.println("(double)7 / 2  = " + ((double) a / b));   // 3.5

        // Error frecuente: casting al resultado (ya truncado)
        System.out.println("(double)(7 / 2)= " + ((double) (a / b))); // 3.0
    }
}

🔹 División por cero

La división por cero tiene consecuencias diferentes según el tipo de datos:

public class DivisionPorCero {
    public static void main(String[] args) {

        // Con enteros: ArithmeticException
        // int x = 10 / 0;  ← Lanza java.lang.ArithmeticException

        // Con punto flotante: valores especiales IEEE 754
        System.out.println(10.0 / 0);     // Infinity
        System.out.println(-10.0 / 0);    // -Infinity
        System.out.println(0.0 / 0);      // NaN (Not a Number)
    }
}

🔄 El operador módulo (%)

El operador % devuelve el resto de la división entera entre dos números. Es uno de los operadores más versátiles y se utiliza con frecuencia para resolver problemas clásicos de programación.

🔹 Usos habituales del módulo

▶️ Ejemplo: clasificar números pares e impares

public class ParidadNumeros {
    public static void main(String[] args) {

        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                System.out.println(i + " es par");
            } else {
                System.out.println(i + " es impar");
            }
        }
    }
}

🔹 Módulo con números negativos

En Java, el signo del resultado del operador % coincide con el signo del dividendo (primer operando):

System.out.println( 7 % 3);    //  1  (positivo porque 7 es positivo)
System.out.println(-7 % 3);    // -1  (negativo porque -7 es negativo)
System.out.println( 7 % -3);   //  1  (positivo porque 7 es positivo)
System.out.println(-7 % -3);   // -1  (negativo porque -7 es negativo)

🔼 Incremento (++) y decremento (--)

Los operadores ++ y -- son atajos para sumar o restar 1 a una variable. Existen en dos formas que se comportan de manera distinta cuando se usan dentro de una expresión:

▶️ Diferencia entre prefijo y postfijo

public class IncrementoDecremento {
    public static void main(String[] args) {

        int x = 5;

        // Postfijo: usa el valor actual y DESPUÉS incrementa
        int a = x++;           // a = 5, x = 6
        System.out.println("a = " + a + ", x = " + x);

        // Prefijo: incrementa PRIMERO y luego usa el valor
        int b = ++x;           // x = 7, b = 7
        System.out.println("b = " + b + ", x = " + x);

        // Decremento postfijo
        int c = x--;           // c = 7, x = 6
        System.out.println("c = " + c + ", x = " + x);
    }
}

📊 Precedencia y asociatividad

Cuando una expresión contiene varios operadores, Java los evalúa siguiendo un orden de precedencia (prioridad) y, para operadores del mismo nivel, una regla de asociatividad (izquierda a derecha o derecha a izquierda):

▶️ Ejemplo de evaluación paso a paso

int resultado = 2 + 3 * 4 - 6 / 2;

// Paso 1: multiplicación y división (prioridad 2, izq → der)
//   3 * 4 = 12
//   6 / 2 = 3
// Paso 2: suma y resta (prioridad 3, izq → der)
//   2 + 12 - 3 = 11

System.out.println(resultado);  // 11

🔀 Promoción de tipos en operaciones

Cuando los operandos de una expresión aritmética tienen tipos diferentes, Java aplica reglas de promoción automática antes de realizar el cálculo:

▶️ Ejemplo de promoción en acción

public class PromocionTipos {
    public static void main(String[] args) {

        byte x = 10;
        byte y = 20;
        // byte suma = x + y;   ← ERROR: x + y produce int
        int suma = x + y;          // Correcto: resultado es int
        byte sumaB = (byte)(x + y); // Correcto: casting explícito

        int entero = 5;
        double real = 2.5;
        double mezcla = entero + real;  // 5 se promueve a 5.0 → 7.5

        System.out.println("suma   = " + suma);    // 30
        System.out.println("mezcla = " + mezcla);  // 7.5
    }
}

🔗 El operador + con cadenas

En Java, el operador + tiene un doble propósito: cuando al menos uno de los operandos es un String, actúa como operador de concatenación en lugar de realizar una suma aritmética.

🔹 Reglas de concatenación

public class ConcatenacionStrings {
    public static void main(String[] args) {

        // Concatenación básica
        String saludo = "Hola" + " " + "mundo";
        System.out.println(saludo);           // Hola mundo

        // Número + String = concatenación
        System.out.println("Edad: " + 25);      // Edad: 25

        // Cuidado con el orden de evaluación
        System.out.println(3 + 4 + " gatos");  // 7 gatos  (suma primero)
        System.out.println("gatos " + 3 + 4);   // gatos 34 (concatena todo)

        // Usar paréntesis para forzar la suma
        System.out.println("gatos " + (3 + 4)); // gatos 7
    }
}

🚫 Errores frecuentes

🏗️ Ejemplo completo integrador

El siguiente programa simula un conversor de unidades de tiempo que recibe un número de segundos y lo descompone en horas, minutos y segundos restantes, utilizando división entera y módulo:

public class ConversorTiempo {

    // Constantes de conversión
    private static final int SEGUNDOS_POR_MINUTO = 60;
    private static final int SEGUNDOS_POR_HORA   = 3600;

    public static void main(String[] args) {

        int totalSegundos = 45296;

        // Descomposición con división entera y módulo
        int horas    = totalSegundos / SEGUNDOS_POR_HORA;
        int restante = totalSegundos % SEGUNDOS_POR_HORA;
        int minutos  = restante / SEGUNDOS_POR_MINUTO;
        int segundos = restante % SEGUNDOS_POR_MINUTO;

        // Verificación: reconstruir el total
        int verificacion = horas * SEGUNDOS_POR_HORA
                        + minutos * SEGUNDOS_POR_MINUTO
                        + segundos;

        System.out.println("Total segundos: " + totalSegundos);
        System.out.println("Equivale a:     " + horas + "h "
                        + minutos + "m " + segundos + "s");
        System.out.println("Verificación:   " + verificacion);
    }
}
// Salida:
// Total segundos: 45296
// Equivale a:     12h 34m 56s
// Verificación:   45296

Ampliemos el ejemplo añadiendo un segundo conversor que calcula el desglose de una cantidad de dinero en billetes y monedas:

public class DesgloseDinero {
    public static void main(String[] args) {

        int centimos = 4873;  // 48.73 €

        int euros     = centimos / 100;
        int restoCent = centimos % 100;

        // Desglose de euros en billetes
        int billetes20 = euros / 20;
        int restoEuros = euros % 20;
        int billetes10 = restoEuros / 10;
        int billetes5  = (restoEuros % 10) / 5;
        int monedas1   = (restoEuros % 10) % 5;

        System.out.println("Cantidad: " + euros + "," + restoCent + " €");
        System.out.println("Billetes de 20: " + billetes20);
        System.out.println("Billetes de 10: " + billetes10);
        System.out.println("Billetes de 5:  " + billetes5);
        System.out.println("Monedas de 1:   " + monedas1);
    }
}
// Salida:
// Cantidad: 48,73 €
// Billetes de 20: 2
// Billetes de 10: 0
// Billetes de 5:  1
// Monedas de 1:   3

📝 Ejercicios prácticos

public class EjercicioUno {
    public static void main(String[] args) {
        int a = 10, b = 3;
        System.out.println(a / b);
        System.out.println(a % b);
        System.out.println(a / b * b + a % b);
        System.out.println("Resultado: " + a + b);
        System.out.println("Resultado: " + (a + b));
    }
}

3
1
10
Resultado: 103
Resultado: 13

public class ConversorTemperatura {
    public static void main(String[] args) {

        double[] celsius = {0, 20, 37, 100};

        System.out.println("=== Celsius a Fahrenheit ===");
        for (double c : celsius) {
            double f = c * 9.0 / 5 + 32;
            System.out.printf("%.1f °C = %.1f °F%n", c, f);
        }

        System.out.println("\n=== Fahrenheit a Celsius ===");
        double[] fahrenheit = {32, 68, 98.6, 212};
        for (double f : fahrenheit) {
            double c = (f - 32) * 5.0 / 9;
            System.out.printf("%.1f °F = %.1f °C%n", f, c);
        }
    }
}

public class CalculadoraNotas {
    public static void main(String[] args) {

        int[] notas = {7, 4, 9, 5, 3, 8, 6, 10, 2, 7};

        int suma = 0;
        int max = notas[0];
        int min = notas[0];
        int aprobados = 0;

        for (int nota : notas) {
            suma += nota;                    // Operador += (suma y asigna)
            if (nota > max) max = nota;
            if (nota < min) min = nota;
            if (nota >= 5) aprobados++;     // Operador ++ (incremento)
        }

        double media = (double) suma / notas.length;  // Casting para división real

        System.out.println("Notas analizadas: " + notas.length);
        System.out.println("Suma total:       " + suma);
        System.out.printf("Media:            %.2f%n", media);
        System.out.println("Nota máxima:      " + max);
        System.out.println("Nota mínima:      " + min);
        System.out.println("Aprobados:        " + aprobados);
        System.out.println("Suspensos:        " + (notas.length - aprobados));
    }
}
// Salida:
// Notas analizadas: 10
// Suma total:       61
// Media:            6.10
// Nota máxima:      10
// Nota mínima:      2
// Aprobados:        6
// Suspensos:        4