Java else-if Ladder

In the last lesson you learned about the Java nested if statement. But life often has more than two outcomes, like a grade of A, B, C, D, or F. For many outcomes, you chain conditions into an else-if ladder.

🤔 Why chain conditions?

A plain if-else gives you only two paths. So what about three, four, or ten outcomes?

• Nesting if-else inside if-else works, but the code drifts right and gets hard to read.
• An else-if ladder lines up several checks one after another.
• Java picks the first one that fits.

Think about grading a score out of 100. Here is the rule.

• 90 or above is an A.
• 80 to 89 is a B.
• 70 to 79 is a C.
• 60 to 69 is a D.
• Below 60 is a fail, F.

That is five outcomes, not two. A single true-or-false split cannot cover it. The ladder tests conditions top to bottom and stops at the first one that is true.

🧩 The else-if syntax

An if, then one or more else if blocks, then an optional else at the bottom. else if is just an else whose body is another if. So it is no new keyword. You are chaining tools you already know. Here is the shape.

if (condition1) {
    // runs if condition1 is true
} else if (condition2) {
    // runs if condition1 was false and condition2 is true
} else if (condition3) {
    // runs if the ones above were false and condition3 is true
} else {
    // runs if none of the above were true
}

Here is the whole point of this lesson.

• Java checks the conditions top to bottom.
• The moment one is true, it runs that block.
• It skips every block below, even ones that would also be true.
• If none match, the final else runs.

So exactly one block runs. Like a queue at a single door: the first matching ticket walks through, then the door closes.

Now the grading example in real code. It reads a score and prints the matching grade letter.

int score = 85;

if (score >= 90) {
    System.out.println("Grade: A");
} else if (score >= 80) {
    System.out.println("Grade: B");
} else if (score >= 70) {
    System.out.println("Grade: C");
} else if (score >= 60) {
    System.out.println("Grade: D");
} else {
    System.out.println("Grade: F");
}

Walk through it the way Java does, with a score of 85.

• score >= 90? No. Move on.
• score >= 80? Yes. Java prints “Grade: B”.
• Java stops. The 70, 60, and else checks never run.

The second check is just score >= 80, not score >= 80 && score < 90. You skip the upper bound because:

• You only reach the second check if the first one was false.
• The first being false already means the score is below 90.
• So the ladder has proven the upper bound for you.

Grade: B

🔢 Why order matters

This is the part people get wrong. Java stops at the first true condition, so the order of your checks changes the result. Same conditions, different order, different answer for the same input. Look at this broken version.

int score = 95;

if (score >= 50) {          // ❌ loose check first, catches everything
    System.out.println("Grade: pass (C-ish)");
} else if (score >= 90) {   // never reached for a 95
    System.out.println("Grade: A");
} else if (score >= 80) {
    System.out.println("Grade: B");
}

A score of 95 deserves an A. But the ladder is upside down:

• The first check is score >= 50. For 95, that is true.
• Java runs that block, prints the wrong thing, and stops.
• The score >= 90 check that would give the A never runs.

Grade: pass (C-ish)

This bug is sneaky.

• The code compiles fine and runs fine.
• It just gives a quietly wrong answer, which is the hardest kind to find.

The fix: put the strictest check first, then loosen as you go down.

int score = 95;

if (score >= 90) {          // ✅ strictest check first
    System.out.println("Grade: A");
} else if (score >= 80) {
    System.out.println("Grade: B");
} else if (score >= 50) {
    System.out.println("Grade: pass");
}

Now 95 hits the first check, gets its A, and stops.

💰 A tax-slab example with output

Many countries calculate income tax in slabs, where each band of income has its own rate. This fits the ladder perfectly: income falls into exactly one ordered band. Here we work out a simplified tax band for a yearly income.

int income = 65000;
String band;

if (income <= 20000) {
    band = "0% (no tax)";
} else if (income <= 50000) {
    band = "10% slab";
} else if (income <= 100000) {
    band = "20% slab";
} else {
    band = "30% slab";
}

System.out.println("Income: " + income);
System.out.println("Tax band: " + band);

Trace it for an income of 65000.

• income <= 20000? No. Skip.
• income <= 50000? No. Skip.
• income <= 100000? Yes. band becomes “20% slab”.
• Java stops. The final else for top earners never runs.

The direction flipped here:

• Grades checked top down with >=.
• Tax slabs check bottom up with <=.
• Both are fine. Each check assumes the ones above failed, so you still need only one bound per band.

Income: 65000
Tax band: 20% slab

🛒 A discount-tier example

An online store gives a bigger discount the more you spend. Same ladder idea, used for a shopping cart.

double cartTotal = 120.0;
double discount;

if (cartTotal >= 200) {
    discount = 0.20;        // 20% off for big spenders
} else if (cartTotal >= 100) {
    discount = 0.10;        // 10% off
} else if (cartTotal >= 50) {
    discount = 0.05;        // 5% off
} else {
    discount = 0.0;         // no discount
}

double finalPrice = cartTotal * (1 - discount);
System.out.println("You pay: " + finalPrice);

A cart total of 120 fails the 200 check, passes the 100 check, so it gets 10% off. Java stops. The final price is 120 minus 10%, which is 108.

You pay: 108.0

The highest spend stays at the top. So a shopper spending 250 correctly gets the 20% tier, not the 10% one. Order doing the work again.

🚦 Strings in a ladder

A ladder works with any true-or-false condition, including text. Here a traffic light reads a colour and prints what to do.

String light = "yellow";

if (light.equals("red")) {
    System.out.println("Stop");
} else if (light.equals("yellow")) {
    System.out.println("Slow down");
} else if (light.equals("green")) {
    System.out.println("Go");
} else {
    System.out.println("Unknown light");
}

Key points for this one:

• Use .equals() to compare strings. Never use == for text in Java.
• Java checks “red” (false), then “yellow” (true), so it prints “Slow down”.
• The final else is a safety net for a typo like “yelow”, so the code does something instead of nothing.

Slow down

This is a good moment to mention switch.

• When every check is “is this variable equal to a fixed value?”, switch can be cleaner than a long ladder of .equals() calls.
• But ranges like score >= 90 cannot use a basic switch.
• So the ladder stays the right tool for ranges. We cover switch in the next lesson.

⚠️ Common Mistakes

A few slip-ups trip up almost everyone at first.

Wrong order of conditions. A loose check placed first grabs values meant for stricter checks below, so those never run.

// ❌ Loose check first, so a 95 wrongly gets "C"
if (score >= 70) {
    System.out.println("C");
} else if (score >= 90) {
    System.out.println("A");   // never reached
}

// ✅ Strictest first, so a 95 correctly gets "A"
if (score >= 90) {
    System.out.println("A");
} else if (score >= 70) {
    System.out.println("C");
}

Overlapping ranges the ladder already handles. Over-writing the conditions makes the bounds easy to get wrong.

// ❌ Over-complicated and easy to break (notice the gap: what about exactly 80?)
if (score >= 90) {
    System.out.println("A");
} else if (score >= 80 && score < 89) {   // 89 and 90-edge cases get fumbled
    System.out.println("B");
}

// ✅ Let the ladder prove the upper bound for you
if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {              // already known to be below 90
    System.out.println("B");
}

Using separate ifs instead of else if. Each plain if is checked on its own, so more than one block can run. The ladder is exclusive; separate ifs are not.

// ❌ Separate ifs, both run for a 95
if (score >= 90) { System.out.println("A"); }
if (score >= 80) { System.out.println("B"); }   // also prints!

// ✅ else if chains them, so only one runs
if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {
    System.out.println("B");
}

Forgetting the final else. Without it, if nothing matches, nothing happens. A value can slip through silently, leaving you wondering why nothing printed. Add an else as a catch-all so unexpected input is handled on purpose.

✅ Best Practices

• Order from strictest to loosest. Check the highest or most specific condition first. This one habit prevents most ladder bugs.
• Use else if, not separate ifs. It makes the choices exclusive, so exactly one block runs.
• Let the ladder prove the bounds. Write score >= 80, not score >= 80 && score < 90. Less code, fewer mistakes.
• Add a final else. It handles every case you did not list and stops values slipping through unnoticed.
• Keep each block short. If a branch grows large, move its work into a separate method.
• Reach for switch when it fits. Checking one variable against many fixed values reads cleaner as a switch (next lesson).

🧩 What You’ve Learned

You can handle many outcomes now. Quick recap.

• ✅ The else-if ladder chains several conditions to handle more than two outcomes.
• ✅ Java checks the conditions top to bottom and runs the first one that is true, then stops.
• ✅ Order matters: put the strictest condition first, or a loose one will catch values meant for stricter checks.
• ✅ Each else if assumes the checks above it failed, so you only need one bound per band.
• ✅ A final else is a catch-all for everything that did not match.
• ✅ Use else if, not separate ifs, so only one block runs.
• ✅ Ladders handle ranges; for one variable against fixed values, a switch is often cleaner.

🚀 What’s Next?

When you are checking one variable against many fixed values, there is a cleaner tool: the switch statement. Let’s finish the module with it.

Java switch Statement