Precedencia de operadores y paréntesis en expresiones condicionales

1. Introducción

Empecemos con una analogía cotidiana. Imagina una receta:

Mezcla harina, huevos y azúcar, bate, añade mantequilla, bate otra vez.

¿Suena raro? Ahora imagina que entre las palabras «bate» y «añade» hay una coma o paréntesis. El orden de las acciones se vuelve inmediatamente más claro.

En programación ocurre algo parecido cuando escribes una expresión compleja:

boolean result = a > 0 && b < 10 || c == 3;

¿Cuál es el orden? ¿Qué se evalúa primero: a > 0 && b < 10, y luego || c == 3? ¿O al revés?
Sin un orden de evaluación claro, el ordenador puede «confundir los ingredientes», y tu resultado será inesperado.

2. Precedencia de operadores en Java

Java (como la mayoría de los lenguajes de programación) utiliza una tabla de precedencia de operadores.
Los operadores con mayor precedencia se evalúan antes que los de menor precedencia.

Fíjate en la parte más importante de esta tabla (para expresiones condicionales):

()

!

==, !=

<, >, <=, >=

&&

||

(También existen operadores aritméticos: tienen una precedencia superior a la de los lógicos.)

Regla principal

El operador «Y» (&&) tiene mayor precedencia que «O» (||),
es decir, primero se evalúa «Y» y después «O». No en vano Y es la multiplicación lógica y O la suma.

Diagrama de flujo de evaluación de la precedencia de las condiciones

graph LR
    A["a > 0"] --&&--> B["b < 10"]
    B --||--> C["c == 3"]

(En la práctica: a > 0 && b < 10 || c == 3 — primero se calcula a > 0 && b < 10, luego el resultado se combina con c == 3 mediante ||.)

3. Dirección de evaluación de los operadores: de izquierda a derecha y al revés

Además de la precedencia, hay otra propiedad: asociatividad.
Indica en qué dirección se evalúan los operadores cuando están «uno junto a otro» y tienen la misma precedencia.

Ejemplo:

boolean a = true, b = false, c = true;
boolean result = a && b && c;

Pregunta: ¿cómo se evaluará?
Respuesta: la asociatividad de && es de izquierda a derecha.
Por tanto, primero a && b, y después el resultado con c.

Aplicado a condiciones:

&&, ||

!

4. Los paréntesis — tu mejor aliado en condiciones complejas

Aquí empieza la magia (y la salvación). Cuando escribes una expresión, los paréntesis cambian la precedencia y hacen tu código más claro y seguro.

Ejemplo 1 (sin paréntesis):

// Queremos: «Si el usuario es adulto y ciudadano, o si tiene un pase especial»
boolean isAdult = age >= 18;
boolean isCitizen = country.equals("Bielorrusia");
boolean hasPermit = hasSpecialPass == true;

if (isAdult && isCitizen || hasPermit)
{
    System.out.println("¡Acceso permitido!");
}

Cómo lo evalúa Java:
Primero calcula isAdult && isCitizen, luego combina el resultado con hasPermit mediante ||.

• Supongamos que isAdult = true, isCitizen = false, hasPermit = true
• isAdult && isCitizen → true && false → false
• false || true → true

Es decir, si la persona tiene un pase especial, la dejarán pasar igualmente.
Y si no tiene pase especial pero es un ciudadano adulto — también la dejarán pasar.

Ejemplo 2 (con paréntesis):

if (isAdult && (isCitizen || hasPermit))
{
    System.out.println("¡Acceso permitido!");
}

Ahora el programa comprueba primero: isCitizen || hasPermit, y después ese resultado junto con isAdult.

Es decir, hay que ser adulto y (o bien ciudadano, o bien tener un pase especial).
¡Una pequeña diferencia en los paréntesis — una diferencia enorme en la lógica!