¿Cómo usar operadores y expresiones en Java?

Los operadores en Java son símbolos que realizan cálculos o comparaciones sobre valores y variables.

En esta lección aprenderás a usar tres familias de operadores: aritméticos, de comparación y lógicos. Con ellos podrás calcular descuentos, comparar salarios y tomar decisiones en tu código.

Operadores aritméticos

Los operadores aritméticos realizan cálculos matemáticos básicos. Java usa los siguientes:

El operador % devuelve el residuo de una división. Es útil para saber si un número es par o impar.

Ejemplo 1 — Cálculo de salario mensual

Un empleado de FEMSA gana $680 por día y trabaja 22 días al mes. Calcula su salario mensual y el descuento del IMSS (aproximadamente 3.5%).

public class SalarioFEMSA {
    public static void main(String[] args) {
        double pagoDiario = 680.0;
        int diasTrabajados = 22;
        double salarioBruto = pagoDiario * diasTrabajados;
        double descuentoIMSS = salarioBruto * 0.035;
        double salarioNeto = salarioBruto - descuentoIMSS;

        System.out.println("Salario bruto: $" + (int) salarioBruto);
        System.out.println("Descuento IMSS: $" + descuentoIMSS);
        System.out.println("Salario neto: $" + salarioNeto);
    }
}

Resultado en consola:

Salario bruto: $14,960
Descuento IMSS: $523.6
Salario neto: $14,436.4

Nota que pagoDiario * diasTrabajados es una expresión aritmética. Una expresión combina valores y operadores para producir un resultado.

Ejemplo 2 — Descuento en Liverpool

Liverpool aplica un 15% de descuento en artículos seleccionados. Calcula el precio final de un televisor que cuesta $18,500.

public class DescuentoLiverpool {
    public static void main(String[] args) {
        double precioOriginal = 18500.0;
        double porcentajeDescuento = 0.15;
        double montoDescuento = precioOriginal * porcentajeDescuento;
        double precioFinal = precioOriginal - montoDescuento;

        System.out.println("Precio original: $" + (int) precioOriginal);
        System.out.println("Descuento: $" + (int) montoDescuento);
        System.out.println("Precio final: $" + (int) precioFinal);
    }
}

Resultado en consola:

Precio original: $18,500
Descuento: $2,775
Precio final: $15,725

Operadores de comparación

Los operadores de comparación comparan dos valores y devuelven true o false. Siempre producen un resultado de tipo boolean.

Ejemplo 3 — Verificar si un salario supera el mínimo

En México, el salario mínimo general en 2024 es $248.93 diarios. Verifica si el salario de un trabajador está por encima de ese mínimo.

public class VerificaSalario {
    public static void main(String[] args) {
        double salarioDiario = 350.0;
        double salarioMinimo = 248.93;
        boolean superaMinimo = salarioDiario > salarioMinimo;

        System.out.println("¿Supera el salario mínimo? " + superaMinimo);
    }
}

Resultado en consola:

¿Supera el salario mínimo? true

El valor true se almacena directamente en la variable superaMinimo. Esto es una expresión de comparación.

Operadores lógicos

Los operadores lógicos combinan dos o más expresiones booleanas para tomar decisiones más complejas.

Ejemplo 4 — Validar elegibilidad de crédito en Mercado Libre

Mercado Crédito otorga financiamiento si el cliente tiene más de 6 meses en la plataforma y su calificación es mayor a 4.5 estrellas.

public class CreditoMercadoLibre {
    public static void main(String[] args) {
        int mesesEnPlataforma = 9;
        double calificacion = 4.7;

        boolean tiempoSuficiente = mesesEnPlataforma >= 6;
        boolean buenaCalificacion = calificacion > 4.5;
        boolean elegible = tiempoSuficiente && buenaCalificacion;

        System.out.println("¿Elegible para crédito? " + elegible);
    }
}

Resultado en consola:

¿Elegible para crédito? true

Si cualquiera de las dos condiciones fuera false, el resultado de && sería false. Así funciona el operador AND.

Ejemplo 5 — Descuento por membresía o por monto en Bimbo

Bimbo aplica un descuento especial si el cliente tiene membresía o si su compra supera $5,000.

public class DescuentoBimbo {
    public static void main(String[] args) {
        boolean tieneMembresia = false;
        double montoCompra = 6200.0;
        boolean compraGrande = montoCompra > 5000;

        boolean aplicaDescuento = tieneMembresia || compraGrande;

        System.out.println("¿Aplica descuento? " + aplicaDescuento);
    }
}

Resultado en consola:

¿Aplica descuento? true

Aunque tieneMembresia es false, la condición compraGrande es true. Con || basta una condición verdadera.

Orden de precedencia

Java evalúa los operadores en un orden específico, igual que en matemáticas. Este orden se llama precedencia de operadores.

1. Paréntesis ()
2. Multiplicación *, división /, módulo %
3. Suma +, resta -
4. Comparación >, <, >=, <=, ==, !=
5. AND lógico &&
6. OR lógico ||

Siempre usa paréntesis para dejar claro el orden que deseas. Evita depender de reglas de precedencia implícitas.

Ejemplo sin paréntesis (ambiguo):

double resultado = 5000 + 3000 * 0.10;  // Java calcula 3000 * 0.10 primero
// resultado = 5300, NO 800

Ejemplo con paréntesis (claro):

double resultado = (5000 + 3000) * 0.10;  // primero la suma, luego la multiplicación
// resultado = 800

Errores comunes

Error 1 — Confundir = con ==

El operador = asigna un valor. El operador == compara dos valores. Son completamente distintos.

// INCORRECTO: esto intenta asignar, no comparar
boolean igual = (salario = 10000);  // Error de compilación

// CORRECTO
boolean igual = (salario == 10000);

Error 2 — Dividir enteros y perder decimales

Cuando divides dos int, Java descarta los decimales. Esto produce resultados inexactos.

// INCORRECTO
int resultado = 10 / 3;  // resultado = 3, se pierde el .33

// CORRECTO: usa double
double resultado = 10.0 / 3;  // resultado = 3.3333...

Error 3 — Comparar Strings con ==

El operador == no compara el contenido de dos Strings correctamente en Java. Usa el método .equals() en su lugar.

String ciudad = "Monterrey";

// INCORRECTO
boolean esMty = (ciudad == "Monterrey");  // puede dar false aunque parezca igual

// CORRECTO
boolean esMty = ciudad.equals("Monterrey");  // siempre confiable

Error 4 — Ignorar el operador módulo %

Muchos principiantes ignoran %, pero es muy útil. Por ejemplo, para saber si un número de empleado es par (turno matutino) o impar (turno vespertino):

int numEmpleado = 4731;
boolean esPar = (numEmpleado % 2 == 0);
System.out.println("¿Turno matutino? " + esPar);  // false, porque 4731 es impar

Resumen de operadores

Con estos tres grupos de operadores puedes construir la mayoría de las lógicas que necesitan aplicaciones reales: cálculos de nómina, validaciones de datos, reglas de negocio y más.