Programación en Java/Operadores booleanos

Como deben suponer, trabajan con operandos booleanos. Realizan las operaciones lógicas de conjunción (AND), disyunción (OR), negación (NOT) y la disyunción exclusiva (XOR).

Operadores booleanos

Nombre	Operador	Utilización	Resultado
AND	&&	A && B	verdadero cuando A y B son verdaderos. Evaluación condicional.
OR	||	A || B	verdadero cuando A o B son verdaderos. Evaluación condicional.
NOT	!	!A	verdadero si A es falso.
AND	&	A & B	verdadero cuando A y B son verdaderos. Siempre evalúa ambos operandos.
OR	|	A | B	verdadero cuando A o B son verdaderos. Siempre evalúa ambos operandos.
XOR	^	A ^ B	verdadero cuando A y B son diferentes

Cada una de estas operaciones tiene asociada una tabla de verdad. Esto nos permite ver el resultado de un operador aplicado a las distintas combinaciones de valores que pueden tener los operandos. A continuación mostraremos como se comporta el operador AND mediante su tabla de verdad.

public class TablaAnd {
   public static void main(String args[]){
          boolean x = true;
          boolean y = false;
          boolean a1 = x && x;
          boolean a2 = x && y;
          boolean a3 = y && x;
          boolean a4 = y && y;

          System.out.println("Tabla de verdad de la conjunción");
          System.out.println( x + " AND " + x + " = " + a1 );
          System.out.println( x + " AND " + y + " = " + a2 );
          System.out.println( y + " AND " + x + " = " + a3 );
          System.out.println( y + " AND " + y + " = " + a4 );
   }

}

Si probamos a quitar un ampersand ( & ) del operador, vemos que obtenemos los mismos resultados. Existen dos operadores AND, uno con dos símbolos & y el otro con uno solo. También tenemos dos operadores OR.

boolean x1 = operando1 && operando2; 
boolean x2 = operando1 & operando2;

boolean y1 = operando1 || operando2;
boolean y2 = operando1 |  operando2;

Parece extraño, sobre todo porque tienen la misma tabla de verdad. Pero internamente tienen un comportamiento diferente.

Cuando estamos en presencia de un operador con un solo símbolo, siempre se evalúan ambos operandos. En cambio para el operador con el símbolo repetido, su evaluación cambia según el valor del primer operando. Por ejemplo tenemos la siguiente operación.

boolean x = true && false;

El resultado es falso, pero el intérprete tiene que mirar el segundo operando para saberlo.

boolean x = false && true

Aquí ni se molesta en mirar el último operando, porque la operación AND es verdadera solamente cuando ambos operandos son verdaderos.

En el caso del operador OR, se evalúa el segundo operador si el primero es falso. Cuando es verdadero, no tiene en cuenta el otro operando. El resultado es verdadero sin importar el valor del segundo.

Veamos un caso extremo para mostrar como funciona la evaluación condicional. Tenemos el siguiente programa en donde pretendemos hacer saltar al intérprete con un error.

public class Condicional {
   public static void main(String args[]){
          int x = 0;
          int y = 2;
          boolean b = ( x != 0 ) && ( ( y / x ) != 0 );
          System.out.println(b);
   }
}

Sin ningún tipo de emoción, aburridamente el intérprete nos avisa que el resultado es "false". Ahora verá. Quitemos un símbolo & y quedémonos con uno solo. El resultado es otro :

java.lang.ArithmeticException: / by zero

La primera vez verificó que x!=0 era falso, entonces dio por terminada la operación con el resultado falso. Cuando cambiamos de operador, evaluó los dos operandos y cayó en nuestra trampa. Tuvo que calcular cuanto es y / x dando luego un error de división por cero.

Los operadores booleanos son muy amigos de los relacionales. Se llevan bien porque los últimos dan resultados booleanos. Entre ambos tipos de operadores se pueden construir instrucciones mas complejas.

Por ejemplo, queremos saber si un número está dentro de un rango. Solo tenemos que compararlo con los extremos:

int     y = 4;
boolean x = ( y > 3 ) && ( y < 6 );

Ahora deseamos saber si una variable tiene el valor "a" no importando si es mayúscula o minúscula.

char c = 'b';
boolean x = ( c == 'a' ) || ( c == 'A' );

No olviden que el operador de equivalencia (==) tiene dos símbolos igual (=), si colocan uno solo les dará un error de asignación.