Java: Operadores lógicos

Los operadores lógicos están relacionados con el álgebra de Boole. Evalúan una expresión en la que están implicados uno o dos operandos con valor de tipo boolean. Retornan como resultando un valor lógico, que será true si la evaluación de la expresión es cierta o false en caso contrario.

Existen tres operadores lógicos:

OperadorDescripciónSintaxis
&& And lógico (y) a && b
 || Or lógico (o) a || b
 ! Negación lógica (no) !a

Operador and (&&)

Evalúa dos operandos de tipo lógico (pueden ser expresiones, variables o literales). Si ambos tienen valor true el resultado de la evaluación será true. Con que uno de los dos (o los dos) sea false, el resultado también lo será.

truefalse
truetruefalse
falsefalsefalse

Este operando realiza evaluación de cortocircuito (o evaluación McCarthy). Esto significa que evaluará el primer operando y, si este no tiene valor true no evaluará el segundo. Ya que los dos operandos deben ser true para que la evaluación sea cierta, se puede ignorar el segundo cuando el primero sea false puesto que, el resultado será false indistintamente del valor que tome el segundo operando.

Ejemplos:

En el siguiente ejemplo hay dos expresiones relacionales que devolverán un valor lógico: a > b y b < 0. Como están entre paréntesis se evaluarán primero, y sus valores resultantes serán lo que evalúe el operador &&:

int a = 5;
int b = -1;
(a > b) && (b < 0); //true

a > b: El resultado es true puesto que la variable a tiene valor 5 y la variable b tiene valor -1. Se cumple 5 > -1.

b < 0: El resultado es true puesto que la variable b tiene valor -1. Se cumple -1 < 0.

Como a>b es true y b<0 es true, la expresión (a > b) && (b < 0) se evaluará como true && true, lo que dará como resultado true.

En este segundo ejemplo uno de los operandos tiene valor false:

int a = 5;
int b = -1;
(a == 0) && (b == -1); //false

a == 0: El resultado es false puesto que la variable a tiene valor 5. 5 == 0 no es cierto.

b == -1: El resultado es true ya que b tiene valor -1. -1 == -1 es cierto.

Como a==0 es false y b==-1 es true, la expresión (a == 0) && (b == -1) se evaluará como false && true, lo que dará como resultado false porque no son true los dos operandos.

En este caso, como el primer operando es false, se produce cortocircuito y no se evaluaría el segundo, retornando como valor inmediato false.

Operador or (||)

Evalúa dos operandos de tipo lógico (pueden ser expresiones, variables o literales). Si al menos uno de los dos tiene valor true el resultado de la evaluación será true. Para que el resultado sea false ambos tendrán que serlo.

truefalse
truetruetrue
falsetruefalse

Este operador también realiza evaluación de cortocircuito. Si el primer operando tiene valor true no evaluará el segundo. Ya que, con que uno tenga valor true es suficiente para que la evaluación sea cierta, se puede ignorar el segundo si el primero es true. El resultado será true indistintamente del valor que tome el segundo operando.

Ejemplos:

En el siguiente ejemplo hay dos expresiones relacionales que devolverán un valor lógico: b < 0 y a < b. Como están entre paréntesis se evaluarán primero, y sus valores resultantes serán los que evalúe el operador ||:

int a = 5;
int b = -1;
(b > 0) || (a < b); //true

b < 0: El resultado es true puesto que la variable b tiene valor -1. Se cumple -1 < 0.

a < b: El resultado es false puesto que la variable a tiene valor 5 y la variable b tiene valor -1. No se cumple 5 < -1.

Ya que b < 0 es true a < b es false, la expresión (b < 0) || (a < b) se evaluará como true || false, lo que dará como resultado true, porque al menos uno de los operandos es true.

En este caso, como el primer operando es true, se produce cortocircuito y no se evaluaría el segundo, retornando como valor inmediato true.

En este segundo ejemplo los dos operandos tiene valor false:

int a = 5;
int b = -1;
(a == 0) && (b == a); //false

a == 0: El resultado es false puesto que la variable a tiene valor 5. 5 == 0 no es cierto.

b == a: El resultado es false ya que a tiene valor 5 y b tiene valor -1. 5 == -1 es falso.

Como a == 0 es false y b == a es false, la expresión (a == 0) && (b == a) se evaluará como false || false, lo que dará como resultado false porque no hay al menos un operando con valor true.

Not (!)

El operador de negación evalúa un solo operando con valor lógico y devuelve como resultado el valor de este invertido. Es decir, si el operando tiene valor true este operador devolverá false y viceversa.

Ejemplos:

En este primer ejemplo el operando sobre el que se aplica el operador es una expresión relacional que devuelve true:

int a = 9;
 !(a == 9); //false

a == 9: La variable a toma valor 9. El resultado de la evaluación es true porque se cumple 9 == 9.

Como a == 9 es true la evaluación de !(a == 9) será !true, lo que da como resultado false.

En este otro ejemplo el operando tiene valor false:

int a = -1;
int b = 0;
!(a > b); //true

a > b: La variable a toma valor -1 y la variable b toma valor 0. El resultado de la evaluación es false porque no se cumple -1 > 0.

Como a > b es false la evaluación de !(a > b) será !false, lo que da como resultado la inversión del valor, que es true.

Sígueme:

Deja una respuesta

Subir ↑