Operadores lógicos de Java con ejemplos

Los operadores lógicos se utilizan para realizar operaciones lógicas «Y», «O» y «NO», es decir, la función similar a la puerta AND y la puerta OR en la electrónica digital. Se utilizan para combinar dos o más condiciones/restricciones o para complementar la evaluación de la condición original bajo consideración particular. Una cosa a tener en cuenta es que la segunda condición no se evalúa si la primera es falsa, es decir, tiene un efecto de cortocircuito. Se usa ampliamente para probar varias condiciones para tomar una decisión.

1. Operador AND ( && ) – if( a && b ) [si es verdadero ejecutar si no]
2. Operador OR ( || ) – if( a || b) [si uno de ellos es verdadero ejecutar de lo contrario no]
3. Operador NOT ( ! ) – !(a<b) [devuelve falso si a es menor que b]

Ejemplo de operador lógico en Java

Aquí hay un ejemplo que muestra todos los operadores donde los valores de las variables a, b y c se mantienen iguales para todas las situaciones.

a = 10, b = 20, c = 30

For AND operator:

Condition 1: c > a                 
Condition 2: c > b         

Output: True [Both Conditions are true]  

For OR Operator:    

Condition 1: c > a 
Condition 2: c > b  

Output: True [One of the Condition if true]

For NOT Operator:
Condition 1: c > a
Condition 2: c > b

Output: False [Because the result was true and NOT operator did it's opposite]

1. Operador lógico ‘Y’ (&&) 

Este operador devuelve verdadero cuando ambas condiciones consideradas se cumplen o son verdaderas. Si incluso uno de los dos da falso, el operador resulta falso. En términos simples, cond1 && cond2 devuelve verdadero cuando tanto cond1 como cond2 son verdaderos (es decir, distintos de cero ). 

Sintaxis:

condition1 && condition2

Ilustración:

a = 10, b = 20, c = 20

condition1: a < b
condition2: b == c

if(condition1 && condition2)
d = a + b + c

// Since both the conditions are true
d = 50.

Ejemplo

// Java code to illustrate
// logical AND operator
  
import java.io.*;
  
class Logical {
    public static void main(String[] args)
    {
        // initializing variables
        int a = 10, b = 20, c = 20, d = 0;
  
        // Displaying a, b, c
        System.out.println("Var1 = " + a);
        System.out.println("Var2 = " + b);
        System.out.println("Var3 = " + c);
  
        // using logical AND to verify
        // two constraints
        if ((a < b) && (b == c)) {
            d = a + b + c;
            System.out.println("The sum is: " + d);
        }
        else
            System.out.println("False conditions");
    }
}

Var1 = 10
Var2 = 20
Var3 = 20
The sum is: 50

Ahora, en el siguiente ejemplo, podemos ver el efecto de cortocircuito. Aquí, cuando la ejecución llega a la declaración if, la primera condición dentro de la declaración if es falsa y, por lo tanto, la segunda condición nunca se verifica. Por lo tanto, el ++b (pre-incremento de b) nunca sucede y b permanece sin cambios.

Ejemplo:

import java.io.*;
  
class shortCircuiting {
    public static void main(String[] args)
    {
  
        // initializing variables
        int a = 10, b = 20, c = 15;
  
        // displaying b
        System.out.println("Value of b : " + b);
  
        // Using logical AND
        // Short-Circuiting effect as the first condition is
        // false so the second condition is never reached
        // and so ++b(pre increment) doesn't take place and
        // value of b remains unchanged
        if ((a > c) && (++b > c)) {
            System.out.println("Inside if block");
        }
  
        // displaying b
        System.out.println("Value of b : " + b);
    }
}

Producción:

La salida del operador AND 

2. Operador lógico ‘OR’ (||) 

Este operador devuelve verdadero cuando una de las dos condiciones consideradas se cumple o es verdadera. Si incluso uno de los dos da como resultado verdadero, el operador resulta verdadero. Para que el resultado sea falso, ambas restricciones deben devolver falso. 

Sintaxis:

condition1 || condition2

Ejemplo:

a = 10, b = 20, c = 20

condition1: a < b
condition2: b > c

if(condition1 || condition2)
d = a + b + c

// Since one of the condition is true
d = 50.

// Java code to illustrate
// logical OR operator
  
import java.io.*;
  
class Logical {
    public static void main(String[] args)
    {
        // initializing variables
        int a = 10, b = 1, c = 10, d = 30;
  
        // Displaying a, b, c
        System.out.println("Var1 = " + a);
        System.out.println("Var2 = " + b);
        System.out.println("Var3 = " + c);
        System.out.println("Var4 = " + d);
  
        // using logical OR to verify
        // two constraints
        if (a > b || c == d)
            System.out.println("One or both + the conditions are true");
        else
            System.out.println("Both the + conditions are false");
    }
}

Var1 = 10
Var2 = 1
Var3 = 10
Var4 = 30
One or both the conditions are true

3. Operador lógico ‘NO’ (!)

A diferencia de los dos anteriores, este es un operador unario y devuelve verdadero cuando la condición en consideración no se cumple o es una condición falsa. Básicamente, si la condición es falsa, la operación devuelve verdadero y cuando la condición es verdadera, la operación devuelve falso. 

Sintaxis:

!(condition)

Ejemplo:

a = 10, b = 20

!(a<b) // returns false
!(a>b) // returns true

// Java code to illustrate
// logical NOT operator
import java.io.*;
  
class Logical {
    public static void main(String[] args)
    {
        // initializing variables
        int a = 10, b = 1;
  
        // Displaying a, b, c
        System.out.println("Var1 = " + a);
        System.out.println("Var2 = " + b);
  
        // Using logical NOT operator
        System.out.println("!(a < b) = " + !(a < b));
        System.out.println("!(a > b) = " + !(a > b));
    }
}

Var1 = 10
Var2 = 1
!(a < b) = true
!(a > b) = false