سلاسل else if والقيم الحدّية

Written Explanation

How a chain runs

An else if chain is just if/else where the else block contains another if. Written flat, it reads like a list of questions:

if (score >= 90) {
    grade = 'A';
} else if (score >= 80) {
    grade = 'B';
} else if (score >= 70) {
    grade = 'C';
} else {
    grade = 'F';
}

Java works from top to bottom. It evaluates the first condition; if it is true, it runs that block and skips the rest of the chain entirely. If it is false, it moves to the next condition, and so on. The final else has no condition: it runs when every test above it was false. Only one block ever runs.

This is what makes chains compact. By the time Java reaches score >= 80, it already knows that score >= 90 was false, so the second test does not need to say score >= 80 && score < 90. Each test can lean on all the tests before it.

Order matters

Because the first true test wins, the order is part of the logic. For ranges that grow in one direction, order the tests from the most demanding to the least: >= 90, then >= 80, then >= 70. If you reverse them, score >= 70 would catch a 95 first and the A test would never be reached. Example 3 shows exactly this bug.

A useful habit: for each branch, ask "what do I already know is not true when I get here?" and make sure the condition still describes the right values.

Boundary values

A boundary is the exact value where the result changes. In the grade chain the boundaries are 90, 80, and 70. Boundary bugs come from choosing the wrong operator: score > 90 and score >= 90 give the same answer for 89 and for 95, and differ only at 90.

So test each boundary with three values: the boundary itself, one step below, and one step above where it makes sense. For the whole-number grade chain, that means 91, 90, 89, then 81, 80, 79, and so on. For decimals such as weights, "one step" is a small value like 0.01, so test 1.0 and 1.01 around a boundary at 1.

Work out the expected result by hand first, then run the code; otherwise you will unconsciously accept the output as correct.

Covering every case: gaps, overlaps, and the final else

A well-formed chain has no gaps (a value that matches no branch) and no overlaps (a value that could match two branches, where only the earlier one will ever run). Look at these two attempts for ages:

if (age < 18) { ... } else if (age > 18) { ... }      // gap: 18 matches neither
if (age < 18) { ... } else if (age >= 18) { ... }     // no gap, no overlap

The first one has a hole at exactly 18. The simplest cure is a final else: it catches everything that remains, including values you did not think about, such as negative or enormous numbers. If a final else would be wrong for odd values, add a first test that rejects them (if (score < 0 || score > 100)), then continue the chain.

The compiler helps in one case. If a variable must be set by the chain and some path leaves it unset, Java refuses to compile a later use of it. You will see this in Example 3.