Logical operators in Java

Introduction

Logical operators help you combine or change true/false values to make decisions in your program.

Checking if two conditions are both true before doing something.

Deciding if at least one condition is true to proceed.

Making sure a condition is not true before continuing.

Combining multiple yes/no questions to control program flow.

Syntax

Java

condition1 && condition2  // AND operator
condition1 || condition2  // OR operator
!condition               // NOT operator

&& means both conditions must be true.

|| means at least one condition must be true.

! reverses true to false, and false to true.

Examples

This checks if age is over 18 and the person has an ID.

Java

if (age > 18 && hasID) {
    System.out.println("Allowed to enter");
}

This checks if it is a weekend or a holiday.

Java

if (isWeekend || isHoliday) {
    System.out.println("No work today");
}

This checks if it is not raining.

Java

if (!isRaining) {
    System.out.println("Go outside");
}

Sample Program

This program uses logical operators to decide if someone can drive, if they can relax today, and if they should go for a walk.

Java

public class LogicalOperatorsDemo {
    public static void main(String[] args) {
        boolean hasLicense = true;
        int age = 20;

        if (age >= 18 && hasLicense) {
            System.out.println("You can drive.");
        } else {
            System.out.println("You cannot drive.");
        }

        boolean isWeekend = false;
        boolean isHoliday = true;

        if (isWeekend || isHoliday) {
            System.out.println("You can relax today.");
        } else {
            System.out.println("You have to work today.");
        }

        boolean isRaining = false;
        if (!isRaining) {
            System.out.println("Let's go for a walk.");
        } else {
            System.out.println("Better stay inside.");
        }
    }
}

Important Notes

Remember that && stops checking if the first condition is false (short-circuit).

Similarly, || stops checking if the first condition is true.

Use parentheses to group conditions clearly when combining multiple logical operators.

Summary

Logical operators combine true/false values to control decisions.

&& means both must be true, || means one or both are true, ! reverses the value.

They help your program make smart choices based on multiple conditions.

Practice

1. Which logical operator in Java means "both conditions must be true"?

easy

A. && (AND)

B. || (OR)

C. ! (NOT)

D. ^ (XOR)

Solution

1. Step 1: Understand the meaning of logical AND

   The operator && means both conditions must be true for the whole expression to be true.

2. Step 2: Compare with other operators

   || means one or both true, ! reverses true/false, ^ means exclusive or (one true only).

3. Final Answer:

   && (AND) -> Option A

4. Quick Check:

   Both true = && [OK]

Hint: AND means both true, use && [OK]

Common Mistakes:

• Confusing || (OR) with && (AND)
• Thinking ! means AND
• Mixing up ^ with &&

2. Which of the following is the correct syntax to negate a boolean variable flag in Java?

easy

A. flag = not flag;

B. flag = !flag;

C. flag = ~flag;

D. flag = flag !=;

Solution

1. Step 1: Recall the NOT operator syntax

   In Java, the NOT operator is ! and placed before the boolean variable to reverse its value.

2. Step 2: Check each option

   flag = !flag; uses ! correctly. flag = not flag; uses 'not' which is invalid in Java. flag = ~flag; uses ~ which is bitwise NOT, not for booleans. flag = flag !=; is invalid syntax.

3. Final Answer:

   flag = !flag; -> Option B

4. Quick Check:

   Negate boolean with ! [OK]

Hint: Use ! before boolean to negate it [OK]

Common Mistakes:

• Using 'not' instead of !
• Using bitwise ~ on booleans
• Incorrect syntax like 'flag !=;'

3. What is the output of the following Java code?

boolean a = true;
boolean b = false;
System.out.println(a && b || !b);

medium

A. false

B. Compilation error

C. true

D. Runtime exception

Solution

1. Step 1: Evaluate the expression step-by-step

   a && b is true && false = false. !b is !false = true.

2. Step 2: Apply OR operator

   Now false || true = true.

3. Final Answer:

   true -> Option C

4. Quick Check:

   (true && false) || !false = true [OK]

Hint: Evaluate && first, then ||, then ! [OK]

Common Mistakes:

• Ignoring operator precedence
• Evaluating || before &&
• Confusing !b value

4. Identify the error in this Java code snippet:

boolean x = true;
boolean y = false;
if (x & | y) {
    System.out.println("Yes");
}

medium

A. Invalid use of & | operators together

B. Missing semicolon after if condition

C. Boolean variables cannot be used in if

D. No error, code runs fine

Solution

1. Step 1: Check the if condition syntax

   The condition uses '& |' which is not a valid operator combination in Java.

2. Step 2: Understand valid logical operators

   Valid operators are &&, ||, &, | but not combined as '& |'. This causes a syntax error.

3. Final Answer:

   Invalid use of & | operators together -> Option A

4. Quick Check:

   Operators & and | cannot be combined like '& |' [OK]

Hint: Use && or ||, not mixed & | [OK]

Common Mistakes:

• Confusing bitwise & with logical &&
• Combining & and | without operand
• Thinking no error occurs

5. You want to check if a number n is between 10 and 20 inclusive in Java. Which condition correctly uses logical operators?

hard

A. if (n > 10 && n < 20)

B. if (n >= 10 || n <= 20)

C. if (!(n < 10 && n > 20))

D. if (n >= 10 && n <= 20)

Solution

1. Step 1: Understand the range condition

   To check if n is between 10 and 20 inclusive, both conditions n >= 10 and n <= 20 must be true.

2. Step 2: Analyze each option

   if (n >= 10 || n <= 20) uses || which means either condition true, so it allows numbers outside the range. if (n >= 10 && n <= 20) uses && which correctly requires both conditions true. if (!(n < 10 && n > 20)) negates an impossible condition and is incorrect. if (n > 10 && n < 20) excludes 10 and 20 by using > and <.

3. Final Answer:

   if (n >= 10 && n <= 20) -> Option D

4. Quick Check:

   Both limits true = && [OK]

Hint: Use && to require both conditions true [OK]

Common Mistakes:

• Using || instead of && for range
• Excluding boundary values by using > or <
• Misusing negation for range check