Operadores lógicos en Java

Los operadores lógicos en Java permiten combinar expresiones booleanas —aquellas que solo pueden dar como resultado true o false— para construir condiciones más complejas. Son la base de cualquier estructura de control: sentencias if, bucles while, validaciones de entrada y lógica de negocio en general. Dominar estos operadores es imprescindible para escribir código Java robusto y expresivo.

Java dispone de cuatro operadores lógicos fundamentales: AND (&&), OR (||), NOT (!) y XOR (^). Además, ofrece versiones sin cortocircuito (& y |) que evalúan siempre ambos operandos. En este artículo estudiaremos cada uno en profundidad, con sus tablas de verdad, ejemplos de código ejecutable, errores frecuentes y ejercicios prácticos.

📊 Tabla resumen de operadores lógicos en Java

La siguiente tabla recoge los seis operadores lógicos disponibles en Java junto con su comportamiento y un ejemplo elemental de uso. Es un buen punto de referencia rápida antes de profundizar en cada uno.

🔗 Operador AND lógico (&&)

El operador AND devuelve true únicamente cuando ambos operandos son true. En cualquier otro caso, el resultado es false. Se emplea habitualmente para verificar que se cumplen varias condiciones a la vez, como comprobar que un valor está dentro de un rango o que un objeto no es nulo antes de acceder a sus métodos.

El operador && utiliza evaluación en cortocircuito (short-circuit evaluation): si el primer operando ya es false, Java no evalúa el segundo operando, pues el resultado será false independientemente de su valor. Esta característica tiene implicaciones prácticas importantes que veremos en detalle más adelante.

Tabla de verdad de AND

Ejemplo práctico: validar un rango de edad

Uno de los usos más frecuentes de && es comprobar que un valor se encuentra dentro de un intervalo. Para que la edad sea válida, debe ser al mismo tiempo mayor o igual que 0 y menor o igual que 120.

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

        int edad = 25;

        // Ambas condiciones deben ser verdaderas
        if (edad >= 0 && edad <= 120) {
            System.out.println("Edad válida: " + edad);
        } else {
            System.out.println("Edad fuera de rango.");
        }
    }
}
// Salida: Edad válida: 25

Ejemplo: comprobación de múltiples condiciones

El operador && puede encadenarse para verificar tres o más condiciones simultáneamente. Java las evalúa de izquierda a derecha y se detiene en cuanto encuentra la primera que sea false.

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

        boolean usuarioActivo   = true;
        boolean contrasenaOk    = true;
        boolean cuentaNoExpirada = true;

        // Las tres condiciones deben cumplirse
        if (usuarioActivo && contrasenaOk && cuentaNoExpirada) {
            System.out.println("Acceso concedido.");
        } else {
            System.out.println("Acceso denegado.");
        }
    }
}
// Salida: Acceso concedido.

🔀 Operador OR lógico (||)

El operador OR devuelve true cuando al menos uno de los operandos es true. Solo produce false si ambos operandos son false. Se utiliza para expresar alternativas: basta con que se cumpla una de las condiciones para que el bloque se ejecute.

Al igual que &&, el operador || emplea evaluación en cortocircuito, pero en sentido contrario: si el primer operando es true, Java ya sabe que el resultado será true y no evalúa el segundo operando.

Tabla de verdad de OR

Ejemplo práctico: verificar permisos

En muchos sistemas, un usuario puede acceder a un recurso si tiene permisos de administrador o si es el propietario del recurso. Solo necesitamos que una de las dos condiciones sea verdadera.

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

        boolean esAdmin      = false;
        boolean esPropietario = true;

        // Basta con que una condición sea verdadera
        if (esAdmin || esPropietario) {
            System.out.println("Acceso al recurso permitido.");
        } else {
            System.out.println("Acceso denegado.");
        }
    }
}
// Salida: Acceso al recurso permitido.

Ejemplo: validar día del fin de semana

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

        String dia = "Sábado";

        if (dia.equalsIgnoreCase("Sábado") || dia.equalsIgnoreCase("Domingo")) {
            System.out.println(dia + " es fin de semana.");
        } else {
            System.out.println(dia + " es día laborable.");
        }
    }
}
// Salida: Sábado es fin de semana.

🚫 Operador NOT — negación lógica (!)

El operador NOT es unario: actúa sobre un solo operando e invierte su valor lógico. Si la expresión original es true, NOT la convierte en false, y viceversa. Es especialmente útil para negar condiciones ya existentes sin tener que reescribirlas.

A diferencia de AND y OR, NOT se aplica a una única expresión booleana y tiene la mayor precedencia entre todos los operadores lógicos, por lo que se evalúa antes que &&, || o ^.

Tabla de verdad de NOT

Ejemplo práctico: invertir una condición

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

        boolean encontrado = false;

        // Ejecutar mientras NO se haya encontrado
        while (!encontrado) {
            System.out.println("Buscando...");
            // Simular que lo encontramos
            encontrado = true;
        }

        System.out.println("Elemento encontrado.");
    }
}
// Salida:
// Buscando...
// Elemento encontrado.

Ejemplo: comprobar cadena no vacía

String nombre = "Ana";

// isEmpty() devuelve true si la cadena está vacía
// Negamos para comprobar que NO está vacía
if (!nombre.isEmpty()) {
    System.out.println("El nombre es: " + nombre);
}
// Salida: El nombre es: Ana

⚡ Operador XOR lógico (^)

El operador XOR (OR exclusivo) devuelve true cuando exactamente uno de los operandos es true. Si ambos son true o ambos son false, el resultado es false. Es menos común que AND y OR, pero resulta indispensable en determinadas situaciones lógicas, en criptografía básica y en validaciones donde se exige exclusividad.

A diferencia de && y ||, el operador ^ no tiene evaluación en cortocircuito, ya que siempre necesita conocer el valor de ambos operandos para determinar el resultado. También funciona como operador bit a bit cuando se aplica a tipos enteros (int, long, etc.).

Tabla de verdad de XOR

Ejemplo práctico: una sola opción activa

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

        boolean opcionA = true;
        boolean opcionB = false;

        // Solo una opción debe estar activa
        if (opcionA ^ opcionB) {
            System.out.println("Selección válida: solo una opción activa.");
        } else {
            System.out.println("Error: seleccione exactamente una opción.");
        }
    }
}
// Salida: Selección válida: solo una opción activa.

⚙️ Evaluación en cortocircuito (short-circuit evaluation)

Una de las características más importantes de los operadores && y || en Java es la evaluación en cortocircuito. Este mecanismo consiste en que Java deja de evaluar la expresión en cuanto el resultado queda determinado:

Con && (AND): si el primer operando es false, el resultado será false independientemente del segundo. Java no evalúa el segundo operando. Con || (OR): si el primer operando es true, el resultado será true independientemente del segundo. Java no evalúa el segundo operando.

Este comportamiento no es un mero detalle de rendimiento: tiene consecuencias prácticas directas en la seguridad y corrección del código.

Ejemplo: prevenir NullPointerException

El cortocircuito permite escribir comprobaciones de nulidad de forma segura. En el siguiente ejemplo, si texto es null, la segunda condición nunca se evalúa, y se evita la excepción.

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

        String texto = null;

        // Sin cortocircuito (&) esto lanzaría NullPointerException
        // Con cortocircuito (&&) es seguro:
        if (texto != null && texto.length() > 0) {
            System.out.println("El texto tiene contenido.");
        } else {
            System.out.println("El texto es nulo o está vacío.");
        }
    }
}
// Salida: El texto es nulo o está vacío.

Tabla resumen del cortocircuito

🔧 Operadores sin cortocircuito: & y |

Java también ofrece los operadores & (AND) y | (OR) que, aplicados a valores boolean, funcionan de manera idéntica a && y || en cuanto al resultado lógico, pero con una diferencia crítica: siempre evalúan ambos operandos, sin importar el valor del primero.

Estos operadores son más conocidos como operadores bit a bit (bitwise), ya que su uso principal es manipular bits en tipos enteros. Sin embargo, cuando se aplican a operandos boolean, se comportan como operadores lógicos sin cortocircuito.

int i = 5;

// Con && (cortocircuito): i++ NO se ejecuta
if (false && (i++ > 0)) { }
System.out.println("Tras &&: i = " + i);  // 5

// Con & (sin cortocircuito): i++ SÍ se ejecuta
if (false & (i++ > 0)) { }
System.out.println("Tras &:  i = " + i);  // 6

📐 Precedencia y asociatividad de los operadores lógicos

Cuando una expresión combina varios operadores lógicos, Java los evalúa según un orden de prioridad establecido. Conocer esta precedencia es imprescindible para evitar errores sutiles que pueden pasar desapercibidos durante la compilación.

Ejemplo: precedencia sin paréntesis

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

// && tiene mayor precedencia que ||
// Equivale a: a || (b && c)
boolean resultado = a || b && c;
System.out.println(resultado); // true

// Con paréntesis explícitos para otro comportamiento:
boolean resultado2 = (a || b) && c;
System.out.println(resultado2); // true

// Un caso donde sí cambia el resultado:
boolean x = false, y = true, z = false;
System.out.println(x || y && z);   // false (y && z = false, luego false || false)
System.out.println((x || y) && z); // false (x || y = true, luego true && false)

🛒 Ejemplo completo: sistema de descuentos

El siguiente programa combina todos los operadores lógicos estudiados para implementar un pequeño sistema de descuentos en una tienda online. Observe cómo cada operador cumple un rol diferente en la lógica de negocio.

public class SistemaDescuentos {

    public static void main(String[] args) {

        double totalCompra       = 150.0;
        boolean esClienteVIP     = true;
        boolean tieneCupon       = false;
        boolean esFestivo        = false;
        int unidadesCompradas    = 3;

        // 1. AND: descuento si es VIP Y la compra supera 100 €
        if (esClienteVIP && totalCompra > 100) {
            System.out.println("Descuento VIP del 15% aplicado.");
        }

        // 2. OR: envío gratis si es VIP O la compra supera 50 €
        if (esClienteVIP || totalCompra > 50) {
            System.out.println("Envío gratuito.");
        }

        // 3. NOT: entrega rápida si NO es festivo
        if (!esFestivo) {
            System.out.println("Entrega en 24 horas disponible.");
        }

        // 4. XOR: promoción exclusiva (cupón O VIP, pero no ambos)
        if (esClienteVIP ^ tieneCupon) {
            System.out.println("Promoción exclusiva: regalo sorpresa.");
        }

        // 5. Combinación: descuento por volumen si
        //    (es VIP O tiene cupón) Y compra más de 2 unidades
        if ((esClienteVIP || tieneCupon) && unidadesCompradas > 2) {
            System.out.println("Descuento por volumen del 5% adicional.");
        }
    }
}
// Salida:
// Descuento VIP del 15% aplicado.
// Envío gratuito.
// Entrega en 24 horas disponible.
// Promoción exclusiva: regalo sorpresa.
// Descuento por volumen del 5% adicional.

❌ Errores frecuentes con operadores lógicos

Incluso programadores experimentados cometen ciertos errores al trabajar con operadores lógicos. A continuación se presentan los más habituales y cómo evitarlos.

❌ 1. Confundir = (asignación) con == (comparación)

En Java, = es asignación y == es comparación. Con variables boolean, el error puede pasar desapercibido porque la asignación devuelve un valor válido para la condición:

boolean activo = false;

// ❌ MAL: esto asigna true a 'activo' y la condición siempre se cumple
if (activo = true) { ... }

// ✅ BIEN: comparación correcta
if (activo == true) { ... }

// ✅ MEJOR: forma idiomática en Java
if (activo) { ... }

❌ 2. Olvidar el cortocircuito con efectos secundarios

Si el segundo operando de && o || contiene un efecto secundario (como un incremento o una llamada a método), este podría no ejecutarse debido al cortocircuito:

int i = 5;

// Si la primera condición es false, i++ NO se ejecuta
if (false && (i++ > 0)) { }
System.out.println(i); // 5, no 6

❌ 3. No usar paréntesis en expresiones compuestas

La precedencia de && sobre || puede dar resultados inesperados si no se emplean paréntesis. Es preferible ser explícito:

// ❌ Ambiguo: ¿cuál es la intención?
if (a || b && c) { ... }

// ✅ Claro: se lee sin dudar
if (a || (b && c)) { ... }
if ((a || b) && c) { ... }

❌ 4. Comparar Strings con == en lugar de .equals()

Aunque no es específico de los operadores lógicos, es un error muy común al construir condiciones compuestas. El operador == compara referencias de objetos, no contenido:

String rol = new String("admin");

// ❌ MAL: compara referencias, puede dar false
if (rol == "admin" && usuarioActivo) { ... }

// ✅ BIEN: compara contenido
if (rol.equals("admin") && usuarioActivo) { ... }

✏️ Ejercicios prácticos

Los siguientes ejercicios están diseñados para consolidar los conceptos estudiados. Se recomienda intentar resolverlos antes de consultar la solución.

int x = 10, y = 20, z = 30;
boolean r1 = (x < y) && (y < z);
boolean r2 = (x > y) || (z == 30);
boolean r3 = !(x == y);
boolean r4 = (x < y) ^ (y < z);

System.out.println(r1 + " " + r2 + " " + r3 + " " + r4);

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

        String nombre = "Ana García";
        int    edad   = 34;
        String email  = "ana@empresa.com";

        boolean nombreOk = (nombre != null && !nombre.isEmpty());
        boolean edadOk   = (edad >= 18 && edad <= 99);
        boolean emailOk  = (email != null && email.contains("@"));

        if (nombreOk && edadOk && emailOk) {
            System.out.println("Registro válido.");
        } else {
            System.out.println("Datos incorrectos.");
        }
    }
}
// Salida: Registro válido.

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

        int anio = 2024;

        boolean bisiesto = (anio % 4 == 0 && anio % 100 != 0)
                        || (anio % 400 == 0);

        System.out.println(anio + " es bisiesto: " + bisiesto);
    }
}
// Salida: 2024 es bisiesto: true