We can expand an if-statement by adding additional branches, with a condition that must be satisfied before each associated code block is executed, as well as a final else-block, which executes only when all other conditions fail.
This multi-branch if-statement is an extension of the single-branch if-statement. We may add zero or more else-if parts to the single-branch if-statement, as well as an optional else-part. All else-if and else-parts are optional. See the diagram below.
Figure5.2.1.Parts of a multi-branch if-Statement
The first test must use the if keyword followed by a conditional expression in parentheses and a code block in curly braces. The conditional parts that follow must use the else if keywords to indicate an alternative branch. Only the last branch may have no test condition. This final part must use the else keyword followed by a code block in curly braces. This part executes when all other preceding conditions fail. Only the code block associated with the first successful condition executes. All other code blocks are skipped.
Rule: First True Condition Executes.
When evaluating a multi-branch if-statement, evaluate conditions starting at the top and moving down. The code block associated with the first condition that evaluates to true is the one that executes. In this case, none of the following code blocks execute, even if their conditions evaluate to true.
We can use the multi-branch if-statement to solve the points assignment task of our Dart Game. In fact, if we are careful about the order of conditions tested, we can simplify the complexity of conditions considerably.
With a multi-branch if-statement, because only the first true condition executes, if the second condition is tested at all, we know that the first condition must have evaluated to false. There would be no need to repeat that test; we can assume it is false. Returning to Listing 5.1.3, our two if-statements test the conditions dist < 60 and dist >= 60 && dist < 120. In a multi-branch if-statement, the first part of the conjunction making up the second condition (dist >= 60) would be redundant if we tested them in that order. In other words, if we know that dist < 60 is false, then dist >= 60 must be true, and so it can be eliminated from the second conditional test. In fact, this type of reasoning can be applied to all conditions in the multi-branch if-statement. There is no need to retest a previous condition that must have evaluated to false. A simplified version of our awardPoints(…) method follows.
// Award points to the player's total depending upon where the dart lands
public static void awardPoints(double x1, double y1) {
// Circle parameters
double xc = 300.0, yc = 300.0;
// Compute distance
double dist = Math.sqrt( Math.pow(x1 - xc, 2) + Math.pow(y1 - yc, 2) );
// Branch depending on distance from center
if (dist < 60) {
// In center red circle. Add 4 points.
total = total + 4;
}
else if (dist < 120) {
// In green circle. Add 3 points.
total = total + 3;
}
else if (dist < 180) {
// In blue circle. Add 2 points.
total = total + 2;
}
else if (dist < 240) {
// In yellow circle. Add 1 point.
total = total + 1;
}
}
Listing5.2.2.awardPoints() method with multi-branch if-statements
Each condition is simplified because we can make use of the fact that all previous conditions must have evaluated to false, so there is no need to retest them. We call this strategy Most Common First because we check the subconditions that are most common amongst all if-statement conditions before checking others. This prevents us from having to recheck subconditions for each subsequent branch.
Multi-branch Strategy 2: Most Common First.
Order the conditions in a multi-branch if-statement such that most commonly shared subconditions are checked before others. This lets us simplify the following conditions because we can assume all previous conditions have evaluated to false.
A final multi-branch strategy to consider is Assume and Exclude. This applies when we want to test a number of conditions and store the result in a variable.
For example, let’s say that we want to test if a point is within the unit square, that is, a point has an x-value in [0.0, 1.0] and a y-value in [0.0, 1.0]. We could write a complex conjunction of four inequalities that tests both coordinates as being in the range of each axis, or we could assume the point is in the unit square already and test for conditions that demonstrates it is not in the square. Consider the following method named inUnitSquare(). Rather than forming a complex conjunction for the point coordinates being inside the unit square, it sets the default value of the hit variable to true, meaning it is in the unit square, and then tests if any one of four simple conditions are met that tell us the point is outside the unit square, and changes the default hit variable to false if any one is satified.
// Check if a point (x, y) is in the unit square
public static boolean inUnitSquare(double x, double y) {
// Assume it is
boolean hit = true;
// Exclude half-planes that are out of bounds
if (x > 1.0) {
hit = false;
} else if (x < 0.0) {
hit = false;
} else if (y > 1.0) {
hit = false;
} else if (y < 0.0) {
hit = false;
}
// Return the final value of hit
return hit;
}
Listing5.2.3.inUnitSquare(…) method
Sometimes it is easier to test that any one of several excluding conditions is satified than it is to test that all including conditions are satisfied simultaneously.
Multi-branch Strategy 3: Assume and Exclude.
Assume that some complex condition is true and initialize a flag variable to true. Then check that any one of several excluding conditions is statisfied, and set the flag to false if this is the case. Return the flag variable.
The strategy you choose to employ will depend upon the nature of the problem you are solving. The simpler the strategy you choose, the less likely a mistake will be made.
