Operadores lógicos en Java: &&, ||, !

Los operadores lógicos combinan valores boolean en pruebas más complejas. Java proporciona tres: AND (&&), OR (||) y NOT (!). La característica clave de && y || — que realizan cortocircuito — es lo que los hace seguros de usar incluso cuando un operando podría lanzar una excepción.

Normalmente construyes los operandos boolean a partir de operadores de comparación (como >= o !=) y luego los combinas con los operadores lógicos de esta página. Esta página cubre cada operador, la evaluación en cortocircuito, la precedencia de operadores, los patrones comunes del mundo real y las leyes de De Morgan.

Los tres operadores

Operador	Nombre	Resultado
`&&`	AND	`true` solo si ambos operandos son `true`
`\|\|`	OR	`true` si al menos un operando es `true`
`!`	NOT	invierte un `boolean` — `!true` es `false`

Su comportamiento completo cabe en una pequeña tabla de verdad:

`a`	`b`	`a && b`	`a \|\| b`	`!a`
`true`	`true`	`true`	`true`	`false`
`true`	`false`	`false`	`true`	`false`
`false`	`true`	`false`	`true`	`true`
`false`	`false`	`false`	`false`	`true`

boolean isAdult = age >= 18;
boolean hasTicket = ticket != null;

if (isAdult && hasTicket) {
    enterCinema();
}

if (isHoliday || isWeekend) {
    sleepIn();
}

if (!isLoggedIn) {
    redirectToLogin();
}

Nota

Los operadores lógicos solo funcionan con valores boolean, no con números. Java no tiene "truthy" ni "falsy" — if (count) es un error de compilación; escribe if (count > 0) en su lugar. No confundas los operadores lógicos &&/|| con el operador de comparación ==: la comparación produce el boolean, los operadores lógicos combinan varios de ellos.

Evaluación en cortocircuito

&& evalúa su lado derecho solo si el lado izquierdo es true. Si el izquierdo es false, el resultado ya se conoce y el derecho se omite:

boolean leftFalse = false && expensiveCall();   // expensiveCall() never runs

|| hace lo contrario — omite el lado derecho si el izquierdo es true:

boolean leftTrue = true || expensiveCall();     // expensiveCall() never runs

Esto es esencial para las comprobaciones de null:

if (user != null && user.isActive()) { ... }

Si user es null, el lado derecho se omite — sin NullPointerException. Invertirlos causaría un fallo:

if (user.isActive() && user != null) { ... }   // NPE when user is null

La regla general: pon primero la comprobación más barata, más segura o con más probabilidad de fallar.

`&` y `|` sin cortocircuito

Java también tiene & y | (de un solo carácter). Con booleanos calculan el mismo AND/OR, pero siempre evalúan ambos lados. Raramente querrás esto — existe principalmente para las variantes a nivel de bits sobre enteros (cubiertas en Java Bitwise Operators).

boolean a = false & expensiveCall();   // expensiveCall() DOES run
boolean b = true | expensiveCall();    // expensiveCall() DOES run

Si te encuentras usando & o | con booleanos, casi con toda seguridad quieres && y ||.

Combinación de operadores

Puedes encadenar operadores lógicos para construir cualquier prueba booleana:

boolean validAge = age >= 13 && age < 120;
boolean validUser = (name != null && !name.isBlank()) && validAge;

if (isWeekend || (isHoliday && !isWorkRequired)) {
    relax();
}

! tiene la mayor precedencia, luego &&, luego ||. Cuando los mezcles, añade paréntesis para mayor claridad aunque no sean estrictamente necesarios.

Patrones comunes

Comprobaciones de rango — combina dos pruebas relacionales con &&:

if (x >= 0 && x < array.length) { ... }

Lista blanca — combina varios iguales con ||:

if (status.equals("READY") || status.equals("RUNNING") || status.equals("DONE")) { ... }

(Para listas largas, prefiere List.of(...).contains(status) o un switch.)

Cláusulas de guarda — falla rápido con !:

if (!isAuthenticated) {
    throw new AuthException();
}
// ... main logic ...

Leyes de De Morgan

Cuando niegas una expresión combinada, los operadores se invierten:

!(a && b)    is the same as    !a || !b
!(a || b)    is the same as    !a && !b

Así, !(age >= 18 && hasId) es age < 18 || !hasId. La mayoría de los lectores prefieren la forma positiva cuando es posible — refactoriza hacia lo que sea más fácil de leer.

Una demostración

java— editable, runs on the server

Qué viene a continuación

Java If...Else — donde estas pruebas booleanas se utilizan realmente para ramificar tu código.
Java Bitwise Operators — para los raros momentos en que realmente necesitas manipular bits en bruto.

Práctica

¿Qué expresión comprueba de forma segura que user no es null Y que user.isActive() devuelve true?

user != null && user.isActive()user.isActive() && user != nulluser != null & user.isActive()!(user == null) && user.isActive()