Common Errors and Pitfalls in selection statements
Tags: java, programming, learning, beginners
Published: 2024-05-02 11:46:55

Forgetting necessary braces, ending an **if** statement in the wrong place, mistaking **==** for **=**, and dangling **else** clauses are common errors in selection statements. Duplicated statements in **if-else** statements and testing equality of double values are common pitfalls.

## Common Error 1: Forgetting Necessary Braces

The braces can be omitted if the block contains a single statement. However, forgetting the braces when they are needed for grouping multiple statements is a common programming error. If you modify the code by adding new statements in an if statement without braces, you will have to insert the braces. For example, the following code in (a) is wrong. It should be written with braces to group multiple statements, as shown in (b).

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mm60gxedd644wgtfqvyd.png)

## Common Error 2: Wrong Semicolon at the **if** Line

Adding a semicolon at the end of an **if** line, as shown in (a) below, is a common mistake. This mistake is hard to find, because it is neither a compile error nor a runtime error; it is a logic error. The code in (a) is equivalent to that in (b) with an empty block. This error often occurs when you use the next-line block style. Using the end-of-line block style can help prevent this error.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wvwf4nqi43464j03wl1e.png)

## Common Error 3: Redundant Testing of Boolean Values

To test whether a **boolean** variable is **true** or **false** in a test condition, it is redundant to use the equality testing operator like the code in (a):

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bfyn0hns01n6fjr177w8.png)

Instead, it is better to test the **boolean** variable directly, as shown in (b). Another good reason for doing this is to avoid errors that are difficult to detect. Using the **=** operator instead of the **==** operator to compare the equality of two items in a test condition is a common error. It could lead to the following erroneous statement:

```
if (even = true)
 System.out.println("It is even.");
```
This statement does not have compile errors. It assigns **true** to **even**, so that **even** is always **true**.

## Common Error 4: Dangling else Ambiguity

The code in (a) below has two **if** clauses and one **else** clause. Which **if** clause is matched by the **else** clause? The indentation indicates that the **else** clause matches the first **if** clause. However, the **else** clause actually matches the second **if** clause. This situation is known as the _dangling else ambiguity_. The **else** clause always matches the most recent unmatched **if** clause in the same block. So, the statement in (a) is equivalent to the code in (b).

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/r1qpjfs5kt2pqtaql6aw.png)

Since **(i > j)** is false, nothing is displayed from the statements in (a) and (b). To force the **else** clause to match the first **if** clause, you must add a pair of braces:

```
int i = 1, j = 2, k = 3;

if (i > j) {
 if (i > k)
  System.out.println("A");
}
else
 System.out.println("B");
```
This statement displays **B**.

## Common Error 5: Equality Test of Two Floating-Point Values

Floating-point numbers have a limited precision and calculations; involving floating-point numbers can introduce round-off errors. So, equality test of two floating-point values is not reliable. For example, you expect the following code to display **true**, but surprisingly it displays **false**.

```
double x = 1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1;
System.out.println(x == 0.5);
```
Here, **x** is not exactly **0.5**, but is **0.5000000000000001**. You cannot reliably test equality of two floating-point values. However, you can compare whether they are close enough by testing whether the difference of the two numbers is less than some threshold. That is, two numbers _x_ and _y_ are very close if _|x−y| < e_ for a very small value, _e. e_, a Greek letter pronounced epsilon, is commonly used to denote a very small value. Normally, you set _e_ to 10^-14 for comparing two values of the **double** type and to 10^-7 for comparing two values of the **float** type. For example, the following code

```
final double EPSILON = 1E-14;
double x = 1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1;
if (Math.abs(x - 0.5) < EPSILON)
 System.out.println(x + " is approximately 0.5");
```
will display that

`0.5000000000000001 is approximately 0.5`

The **Math.abs(a)** method can be used to return the absolute value of **a**.

## Common Pitfall 1: Simplifying Boolean Variable Assignment

Often, new programmers write the code that assigns a test condition to a **boolean** variable like the code in (a):

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rtnnd0pknz2f1rhqdblv.png)

This is not an error, but it should be better written as shown in (b).

## Common Pitfall 2: Avoiding Duplicate Code in Different Cases

Often, new programmers write the duplicate code in different cases that should be combined in one place. For example, the highlighted code in the following statement is duplicated.

```
if (inState) {
 tuition = 5000;
System.out.println("The tuition is " + tuition);
}
else {
 tuition = 15000;
System.out.println("The tuition is " + tuition);
}
```
This is not an error, but it should be better written as follows:

```
if (inState) {
 tuition = 5000;
}
else {
 tuition = 15000;
}
System.out.println("The tuition is " + tuition);
```

The new code removes the duplication and makes the code easy to maintain, because you only need to change in one place if the print statement is modified.