Java Logical Operators with Examples

Try it on GfG Practice

Logical operators are used to perform logical “AND”, “OR“, and “NOT” operations, i.e., the functions similar to AND gate and OR gate in digital electronics. They are used to combine two or more conditions/constraints or to complement the evaluation of the original condition under particular consideration. One thing to keep in mind is that, while using the AND operator, the second condition is not evaluated if the first one is false. While using the OR operator, the second condition is not evaluated if the first one is true, i.e., the AND and OR operators have a short-circuiting effect. Used extensively to test for several conditions for making a decision.

• AND Operator (&&): If( a && b ) [if true execute else don’t]
• OR Operator (||): If( a || b) [if one of them is true to execute; else don’t]
• NOT Operator (!): !(a<b) [returns false if a is smaller than b]

Example of Logical Operators in Java

Here is an example depicting all the operators where the values of variables a, b, and c are kept the same for all the situations.

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]

Logical AND Operator (&&) with Example

This operator returns true when both the conditions under consideration are satisfied or are true. If even one of the two yields false, the operator results false. In Simple terms, cond1 && cond2 returns true when both cond1 and cond2 are true (i.e. non-zero). 

Syntax:

condition1 && condition2

Illustration:

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.

Example:

// Java code to illustrate
// logical AND operator
import java.io.*;

class Geeks {
    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

Short-Circuiting in AND

Now in the below example, we can see the short-circuiting effect. Here, when the execution reaches to if statement, the first condition inside the if statement is false and so the second condition is never checked. Thus the ++b(pre-increment of b) never happens, and b remains unchanged.

Example:

import java.io.*;

class Geeks {
    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);
    }
}

Value of b: 20
Value of b: 20

Output:

Logical OR Operator (||) with Example

This operator returns true when one of the two conditions under consideration is satisfied or is true. If even one of the two yields true, the operator results true. To make the result false, both the constraints need to return false. 

Syntax:

condition1 || condition2

Example:

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.

Illustration:

// Java code to illustrate
// logical OR operator
import java.io.*;

class Geeks {
    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

Short-Circuiting in OR

Now in the below example, we can see the short-circuiting effect for OR operator. Here, when the execution reaches to if statement, the first condition inside the if statement is true and so the second condition is never checked. Thus the ++b (pre-increment of b) never happens, and b remains unchanged.

Example:

import java.io.*;

class Geeks {
    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 OR
        // Short-circuiting effect as the first condition is true
        // 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");
        
        // displaying b
        System.out.println("Value of b: " +b);
      
    }
}

Value of b: 20
Inside if
Value of b: 20

Logical NOT Operator (!) with Example

Unlike the previous two, this is a unary operator and returns true when the condition under consideration is not satisfied or is a false condition. Basically, if the condition is false, the operation returns true and when the condition is true, the operation returns false. 

Syntax:

!(condition)

Example:

a = 10, b = 20

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

Illustartion:

// Java code to illustrate
// logical NOT operator
import java.io.*;

class Geeks {
    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

Using Logical Operators with Boolean Values

Syntax:

boolean a = true;
boolean b = false;

Example:

public class Geeks {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a: " + a);
        System.out.println("b: " + b);
        System.out.println("a && b: " + (a && b));
        System.out.println("a || b: " + (a || b));
        System.out.println("!a: " + !a);
        System.out.println("!b: " + !b);
    }
}

a: true
b: false
a && b: false
a || b: true
!a: false
!b: true

Explanation: The above example demonstrates the use of logical operator with two boolean variables. The AND (&&) operator returns true if both the variable a and b are true, otherwise it returns false. The OR (||) operator return true if either a and b is true otherwise it return false. The NOT (!) operator reverse the value of the operand. It means !a is false and !b is true.

Advantages

The advantages of logical operators are listed below:

• Short-circuit evaluation: One of the main advantages of logical operators is that they support short-circuit evaluation. It means if the first condition is correct stop checking for the second conditon. It reduce the unnecessary computation and also optimize the performance.
• Readability: Logical operator makes the mode more easy to understand.
• Flexibility: Logical operator allows combining various operator in different ways to handle complex situation.
• Reusability: With the help of logical operator, we can use the same logic on different parts of the program.
• Debugging: With the help of logical operator, the debugging become easier.

Disadvantages

The Disadvantages of logical operators are listed below:

• Limited expressiveness: Logical operators are not good for complex conditions, where we need to check mutliple conditions in a specific order. If-else statements are better choice in such conditions.
• Potential for confusion: Sometimes logical operatos are very confusing. It is required to use paranthese to show the order of checking the conditions.
• Boolean coercion: Logical operator can also cause unexpected result, if they are used with values that are not true or false.

Overall, logical operators are an important tool for developers and play a crucial role in the implementation of complex conditions in a program. They help to improve the readability, flexibility, reusability, and debuggability of the code.

chinmoy lenka

Follow

Improve

Article Tags :

• Java
• Java-Operators

Practice Tags :

• Java
• Java-Operators