You already think this way: "If it's raining, take an umbrella. Otherwise, leave it at home." Java's if/else is exactly that — translated into code. The syntax is the only new thing to learn here.

The `if` Statement

The simplest form — run a block of code only if a condition is true.

Syntax:

Java

if (condition) {
    // code runs ONLY if condition is true
}

Java

int score = 85;

if (score >= 60) {
    System.out.println("You passed!");
}

Output:

You passed!

If score were 45, the condition score >= 60 would be false — the block is skipped and nothing prints.

How it works:

The condition inside ( ) must be a boolean expression — something that evaluates to true or false. Comparison operators (==, !=, >, <, >=, <=) and logical operators (&&, ||, !) are what you'll use most often here.

The `else` Clause

else runs a block when the if condition is false. Exactly one of the two blocks will always run.

Syntax:

Java

if (condition) {
    // runs if condition is true
} else {
    // runs if condition is false
}

Java

int age = 16;

if (age >= 18) {
    System.out.println("Access granted.");
} else {
    System.out.println("You must be 18 or older.");
}

Output:

You must be 18 or older.

💡 Exactly one branch always runs. With if/else, there are no gaps and no overlaps — the program always takes one path or the other. This is different from two separate if statements, where both could run (or neither).

Java

// Two separate if statements — BOTH can run:
if (score >= 60) System.out.println("Passed");
if (score < 60)  System.out.println("Failed");

// if/else — exactly ONE runs:
if (score >= 60) System.out.println("Passed");
else             System.out.println("Failed");

The `else if` Chain

else if lets you check multiple conditions in sequence. Java evaluates them top to bottom and runs the first one that is true — then skips all the rest.

Syntax:

Java

if (condition1) {
    // runs if condition1 is true
} else if (condition2) {
    // runs if condition1 is false AND condition2 is true
} else if (condition3) {
    // runs if condition1 and condition2 are false AND condition3 is true
} else {
    // runs if ALL conditions above are false
}

Grade calculator example:

Java

int marks = 78;

if (marks >= 90) {
    System.out.println("Grade: A");
} else if (marks >= 75) {
    System.out.println("Grade: B");   // ← this runs — 78 >= 75
} else if (marks >= 60) {
    System.out.println("Grade: C");
} else if (marks >= 40) {
    System.out.println("Grade: D");
} else {
    System.out.println("Grade: F");
}

Output:

Grade: B

Even though 78 >= 60 and 78 >= 40 are also true, only the first matching branch runs. Once a condition matches, all remaining else if and else blocks are skipped.

💡 Order matters in else if chains. Always put the most specific (strictest) condition first. If you reversed the grade example — checking >= 40 before >= 90 — every student above 40 would get "Grade D", even those with 95 marks.

Single-Statement Shorthand — No Braces

When an if, else, or else if block contains exactly one statement, the curly braces are optional:

Java

// With braces:
if (score >= 60) {
    System.out.println("Passed");
}

// Without braces — same result:
if (score >= 60)
    System.out.println("Passed");

⚠️ Recommendation: always use braces. Omitting them is a known source of bugs. If you add a second statement thinking it's inside the if block — it isn't:

Java

if (score >= 60)
    System.out.println("Passed");
    System.out.println("Congratulations!");   // ← ALWAYS runs, not part of the if!

This is a real bug that has caused serious production incidents in major software. Using braces consistently eliminates this entire category of error.

Nested `if` Statements

You can place if statements inside other if blocks. This is called nesting — use it when a second condition only makes sense after the first is true.

Java

int age    = 22;
boolean hasTicket = true;

if (age >= 18) {
    System.out.println("Age check passed.");

    if (hasTicket) {
        System.out.println("Entry granted — enjoy the event!");
    } else {
        System.out.println("You need a ticket to enter.");
    }

} else {
    System.out.println("Under 18 — entry not permitted.");
}

Output:

Age check passed.
Entry granted — enjoy the event!

💡 Keep nesting shallow. Deep nesting — if inside if inside if — becomes hard to read and debug quickly. If you find yourself at three or more levels deep, consider restructuring with else if or extracting logic into a separate method.

Java

// Deep nesting — hard to follow:
if (isLoggedIn) {
    if (isAdmin) {
        if (hasPermission) {
            // actual logic buried here
        }
    }
}

// Better — early return / guard clauses (once you learn methods):
if (!isLoggedIn) return;
if (!isAdmin)    return;
if (!hasPermission) return;
// actual logic here — flat and clear

Conditions with Logical Operators

You can combine multiple conditions in one if using && (AND) and || (OR):

Java

int age    = 25;
int income = 50000;

// AND — both must be true:
if (age >= 21 && income >= 30000) {
    System.out.println("Eligible for loan.");
}

// OR — at least one must be true:
boolean isWeekend = true;
boolean isHoliday = false;

if (isWeekend || isHoliday) {
    System.out.println("Store closed today.");
}

// NOT — reverses the condition:
boolean isLoggedIn = false;

if (!isLoggedIn) {
    System.out.println("Please log in to continue.");
}

Range check — checking if a value is between two bounds:

Java

int temperature = 24;

if (temperature >= 20 && temperature <= 30) {
    System.out.println("Comfortable temperature.");
}

⚠️ Common range mistake:

Java

// Wrong — mathematically impossible (nothing is simultaneously < 0 AND > 100):
if (score < 0 && score > 100) { ... }

// Correct — use OR for "outside range":
if (score < 0 || score > 100) {
    System.out.println("Invalid score.");
}

Comparing Strings in Conditions

Never use == to compare Strings in if conditions — use .equals():

Java

String role = "admin";

// Wrong:
if (role == "admin") {   // ❌ may not work correctly
    System.out.println("Admin access");
}

// Correct:
if (role.equals("admin")) {   // ✅ always works
    System.out.println("Admin access");
}

// Case-insensitive comparison:
if (role.equalsIgnoreCase("ADMIN")) {   // ✅ "admin", "Admin", "ADMIN" all match
    System.out.println("Admin access");
}

A Complete Example

Java

import java.util.Scanner;

public class ATM {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        double balance = 15000.0;

        System.out.print("Enter withdrawal amount: ₹");
        double amount = scanner.nextDouble();

        if (amount <= 0) {
            // Invalid input
            System.out.println("Amount must be greater than zero.");

        } else if (amount > balance) {
            // Insufficient funds
            System.out.println("Insufficient balance.");
            System.out.println("Your balance: ₹" + balance);

        } else if (amount % 100 != 0) {
            // ATMs dispense in multiples of 100
            System.out.println("Amount must be a multiple of ₹100.");

        } else {
            // All checks passed — process withdrawal
            balance -= amount;
            System.out.println("Dispensing: ₹" + amount);
            System.out.println("Remaining balance: ₹" + balance);
        }

        scanner.close();
    }
}

Sample runs:

Enter withdrawal amount: ₹500
Dispensing: ₹500.0
Remaining balance: ₹14500.0

Enter withdrawal amount: ₹20000
Insufficient balance.
Your balance: ₹15000.0

Enter withdrawal amount: ₹350
Amount must be a multiple of ₹100.

This example shows a real pattern — a chain of else if blocks each handling a specific invalid case, with the final else handling the success case. Only one branch ever runs, and every possible input is handled.

Common Mistakes

1. Using = instead of ==

Java

int x = 5;
if (x = 10) { }    // ❌ compile error — this assigns 10 to x, not a comparison
if (x == 10) { }   // ✅ compares x to 10

2. Missing braces leading to logic errors

Java

if (score >= 60)
    System.out.println("Passed");
    System.out.println("Good job!");   // ❌ always runs — not inside the if

if (score >= 60) {
    System.out.println("Passed");
    System.out.println("Good job!");   // ✅ only runs when score >= 60
}

3. Wrong logical operator for range check

Java

if (age < 0 && age > 120) { }   // ❌ impossible — nothing satisfies both
if (age < 0 || age > 120) { }   // ✅ outside valid range

4. Putting more specific conditions after less specific ones

Java

// Wrong order — marks = 95 hits first condition and gets "D":
if (marks >= 40) System.out.println("Grade D");
else if (marks >= 90) System.out.println("Grade A");   // never reached!

// Correct order — most specific first:
if (marks >= 90) System.out.println("Grade A");
else if (marks >= 40) System.out.println("Grade D");

5. Comparing Strings with ==

Java

if (name == "Arjun") { }         // ❌ unreliable
if (name.equals("Arjun")) { }    // ✅ always correct

6. Forgetting else — gaps in logic

Java

if (score >= 60) {
    status = "Pass";
}
// What if score < 60? 'status' is never assigned — potential bug!

if (score >= 60) {
    status = "Pass";
} else {
    status = "Fail";    // ✅ every case handled
}

Quick Reference

Java

// Basic if
if (condition) {
    // runs when true
}

// if-else
if (condition) {
    // runs when true
} else {
    // runs when false
}

// else-if chain
if (condition1) {
    // runs when condition1 is true
} else if (condition2) {
    // runs when condition1 false, condition2 true
} else {
    // runs when all conditions false
}

// Nested if
if (outerCondition) {
    if (innerCondition) {
        // runs when BOTH are true
    }
}

// Common conditions
if (x == 10) { }          // equals
if (x != 10) { }          // not equals
if (x > 10 && x < 20) { } // range check
if (x < 0 || x > 100) { } // outside range
if (!isActive) { }         // negation
if (name.equals("Arjun")) { } // string comparison

The 3 Things to Remember From This Page

›else if runs the first match only — conditions are checked top to bottom. Put the most specific condition first. Once one matches, all remaining branches are skipped.
›Always use braces { } — even for single-statement blocks. Omitting braces is a well-known source of bugs when code is modified later.
›Never use == for Strings — use .equals() or .equalsIgnoreCase(). == compares object references, not content, and gives unpredictable results with Strings.

Summary

›if — runs a block only when a condition is true
›else — runs when the if condition is false. Exactly one of if/else always runs.
›else if — checks multiple conditions in sequence. First match wins — the rest are skipped.
›Nesting — if inside if. Use sparingly — more than two levels becomes hard to read.
›Logical operators — combine conditions with && (AND), || (OR), ! (NOT)
›Always use braces — even for single statements. Prevents a classic category of bugs.
›String comparison — use .equals() not == in if conditions.
›Order matters — in else if chains, put the most specific condition first.

What to Read Next

Topic	Link
switch statement — alternative to long else-if chains	switch Statement →
Operators — comparison and logical operators	Operators →
Ternary operator — compact one-line if/else	Operators →
for loop — repeating code with conditions	for Loop →
while loop — looping until a condition is false	while Loop →