Operadores en Java

Los operadores son los símbolos que usas para calcular, comparar y combinar valores: +, >, &&… En esta lección los verás todos, agrupados por familias, junto con las trampas que más fallos provocan al empezar: la división entera, la diferencia entre i++ y ++i, y comparar textos con ==.

Operadores aritméticos

int a = 17;
int b = 5;

System.out.println(a + b); // 22
System.out.println(a - b); // 12
System.out.println(a * b); // 85
System.out.println(a / b); // 3
System.out.println(a % b); // 2

La trampa de la división entera

Cuando divides dos enteros, Java hace división entera: descarta los decimales. 17 / 5 da 3, no 3.4. Si quieres decimales, al menos uno de los dos operandos debe ser double:

int a = 17;
int b = 5;
System.out.println(17 / 5);         // 3
System.out.println(17.0 / 5);       // 3.4
System.out.println((double) a / b); // 3.4
System.out.println((double) (a / b)); // 3.0

El último caso es el error clásico: los paréntesis hacen que primero se divida en entero (3) y después se convierta a double (3.0). El casting debe ir sobre un operando, no sobre el resultado.

Otro detalle: dividir un entero entre 0 lanza ArithmeticException, pero dividir un double entre 0 da Infinity.

El operador resto %

% devuelve el resto de la división entera. Parece poca cosa, pero se usa muchísimo:

int numero = 14;
System.out.println(numero % 2);    // 0 -> es par
System.out.println(27 % 10);       // 7 -> última cifra
System.out.println(135 % 60);      // 15 -> 135 minutos son 2 h y 15 min
System.out.println(135 / 60);      // 2

• n % 2 == 0 comprueba si un número es par.
• n % 10 saca la última cifra.
• / y % juntos convierten unidades: minutos en horas y minutos, segundos en minutos y segundos…

+ con textos

Si uno de los operandos es un String, + concatena. Java evalúa de izquierda a derecha, y eso da sorpresas:

System.out.println("Total: " + 2 + 3);   // Total: 23
System.out.println("Total: " + (2 + 3)); // Total: 5
System.out.println(2 + 3 + " euros");    // 5 euros

En el primero, "Total: " + 2 ya es texto, y luego se le pega el 3. Usa paréntesis cuando mezcles sumas y textos.

Incremento y decremento

++ suma 1 y -- resta 1. Se pueden escribir delante (prefijo) o detrás (postfijo), y la diferencia importa cuando se usan dentro de una expresión:

int x = 5;
int y = x++;  // postfijo: primero usa el valor (5), luego incrementa
System.out.println(y); // 5
System.out.println(x); // 6

int m = 5;
int n = ++m;  // prefijo: primero incrementa, luego usa el valor (6)
System.out.println(n); // 6
System.out.println(m); // 6

Solos en una línea (x++; o ++x;) hacen exactamente lo mismo.

Consejo: no metas ++ dentro de expresiones más largas. int r = x++ + ++x; es legal, pero nadie debería tener que descifrarlo. Incrementa en su propia línea.

Asignación compuesta

Combinan una operación con la asignación:

int puntos = 10;
puntos += 5;  // puntos = puntos + 5
puntos -= 2;  // puntos = puntos - 2
puntos *= 2;  // puntos = puntos * 2
puntos /= 4;  // puntos = puntos / 4
puntos %= 4;  // puntos = puntos % 4
System.out.println(puntos); // 2

Paso a paso: 10 → 15 → 13 → 26 → 6 → 2.

Tienen una particularidad: hacen un casting automático al tipo de la variable.

int total = 10;
total += 2.7;      // compila: equivale a total = (int) (total + 2.7)
System.out.println(total); // 12
// total = total + 2.7; // no compila: double no cabe en int

Operadores de comparación

Comparan dos valores y devuelven un boolean:

Operador	Significado	Ejemplo (edad = 20)	Resultado
==	igual	edad == 20	true
!=	distinto	edad != 30	true
>	mayor	edad > 18	true
<	menor	edad < 18	false
>=	mayor o igual	edad >= 20	true
<=	menor o igual	edad <= 19	false

No confundas = (asignar) con == (comparar). En Java, if (edad = 20) no compila, lo que te salva de un error típico en otros lenguajes.

Comparar textos: equals, no ==

Con objetos, y String es un objeto, == compara si las dos variables apuntan al mismo objeto en memoria, no si tienen el mismo texto. A veces funciona por casualidad (Java reutiliza los literales iguales) y a veces no, lo que lo hace aún más peligroso:

String a = "hola";
String b = "hola";
String c = new String("hola");

System.out.println(a == b);                   // true (casualidad)
System.out.println(a == c);                   // false
System.out.println(a.equals(c));              // true
System.out.println(a.equalsIgnoreCase("HOLA")); // true

Regla: primitivos (int, double, char, boolean) con ==; textos y objetos siempre con .equals(). Tienes más detalles en String y StringBuilder.

Operadores lógicos

Combinan condiciones:

Operador	Nombre	Es true cuando…
&&	Y (AND)	las dos condiciones son true
||	O (OR)	al menos una es true
!	NO (NOT)	la condición es false

int edad = 20;
boolean tieneEntrada = true;

System.out.println(edad >= 18 && tieneEntrada); // true
System.out.println(edad < 18 || tieneEntrada);  // true
System.out.println(!tieneEntrada);              // false

Evaluación en cortocircuito

&& y || dejan de evaluar en cuanto saben el resultado:

• En A && B, si A es false, el resultado ya es false y B no se evalúa.
• En A || B, si A es true, B no se evalúa.

Esto no es un detalle académico: sirve para protegerte de errores.

int alumnos = 0;
int sumaNotas = 0;

if (alumnos > 0 && sumaNotas / alumnos >= 5) {
    System.out.println("Grupo aprobado");
} else {
    System.out.println("Sin datos o suspenso"); // Sin datos o suspenso
}

Como alumnos > 0 es falso, la división nunca se ejecuta y no hay ArithmeticException. El mismo truco sirve para comprobar texto != null && texto.isEmpty(). Pon siempre primero la condición que protege.

Operador ternario

Es un if-else en una sola expresión: condicion ? valorSiTrue : valorSiFalse.

int nota = 6;
String resultado = nota >= 5 ? "Aprobado" : "Suspenso";
System.out.println(resultado); // Aprobado

int unidades = 1;
System.out.println(unidades + (unidades == 1 ? " producto" : " productos")); // 1 producto

Úsalo para elegir entre dos valores sencillos. Si hay lógica o más de dos opciones, un if o un switch se leen mejor (los verás en condicionales).

Precedencia de operadores

Cuando una expresión tiene varios operadores, Java sigue un orden, igual que en matemáticas la multiplicación va antes que la suma:

Prioridad	Operadores	Ejemplo
1 (más alta)	(), x++, x--	(a + b)
2	++x, --x, !, - unario, casting	!activo, (int) x
3	*, /, %	a * b
4	+, -	a + b
5	<, >, <=, >=, instanceof	a < b
6	==, !=	a == b
7	&&	a && b
8	||	a || b
9	? :	a ? b : c
10 (más baja)	=, +=, -=…	a += b

System.out.println(2 + 3 * 4);   // 14
System.out.println((2 + 3) * 4); // 20
System.out.println(true || false && false); // true

En el último, && va antes que ||: se calcula false && false (false) y luego true || false. No hace falta memorizar la tabla: cuando dudes, pon paréntesis. Hacen el código más claro para ti y para quien lo lea.

Operadores de bits (breve)

Trabajan con la representación binaria de los enteros. Los usarás poco al principio, pero conviene reconocerlos:

int a = 6;  // 110 en binario
int b = 3;  // 011
System.out.println(a & b);  // 2  (010) Y bit a bit
System.out.println(a | b);  // 7  (111) O bit a bit
System.out.println(a ^ b);  // 5  (101) O exclusivo
System.out.println(a << 1); // 12 desplaza a la izquierda: multiplica por 2
System.out.println(a >> 1); // 3  desplaza a la derecha: divide entre 2

No confundas & con &&: con boolean, & y | también funcionan, pero no hacen cortocircuito y evalúan siempre los dos lados.

instanceof

Comprueba si un objeto es de un tipo concreto:

Object dato = "Hola";
System.out.println(dato instanceof String);  // true
System.out.println(dato instanceof Integer); // false

if (dato instanceof String texto) {
    System.out.println(texto.length()); // 4
}

La segunda forma (Java 16+) comprueba el tipo y además crea la variable texto ya convertida. Le sacarás todo el partido en polimorfismo.

Errores frecuentes

• División entera: 5 / 2 es 2. Convierte un operando a double.
• Casting en el sitio equivocado: (double) (a / b) convierte cuando ya se han perdido los decimales.
• == con String: usa equals.
• Concatenar sin paréntesis: "Total: " + 2 + 3 da Total: 23.
• Orden en el cortocircuito: sumaNotas / alumnos > 5 && alumnos > 0 falla; la protección debe ir primero.

Resumen

Familia	Operadores
Aritméticos	+ - * / %
Incremento	++ -- (prefijo y postfijo)
Asignación	= += -= *= /= %=
Comparación	== != > < >= <=
Lógicos	&& || ! (con cortocircuito)
Ternario	condicion ? a : b
Bits	& | ^ << >>
Tipo	instanceof

Las funciones matemáticas como potencias, raíces o redondeos están en la clase Math, que verás en Math y clases envoltorio. Antes, aprende a pedir datos al usuario con Scanner.

int a = 7;
int b = 2;
System.out.println(a / b);

String a = "hola";
String b = "hola";

int x = 5;
int y = x++;
int z = ++x;
System.out.println(y + " " + z + " " + x);

System.out.println("Suma: " + 4 + 2);
System.out.println(4 + 2 + " es la suma");