Handling Exceptional Conditions

Subsection 10.2.1 Introducing an Exception

To introduce you to handling exceptional conditions, Listing 10.2.1 shows a method that computes the average of the first N integers, an admittedly contrived example. We use it mainly to illustrate the basic concepts involved in exception handling. As its precondition suggests, the avgFirstN() method expects that N will be greater than 0. If N happens to be 0, an error will occur in the expression sum/N, because you cannot divide an integer by 0. Try it to see this error.

🔗

Listing 10.2.1. Poor design. No attempt is made to guard against a divide-by-zero error.

🔗

/**
* Precondition:  N > 0
* Postcondition: avgFirstN() = (1+2+...+N)/N
*/
public double avgFirstN(int N) {
  int sum = 0;
  for (int k = 1; k <= N; k++)
      sum += k;
  return sum/N;         // What if N is 0?
} // avgFirstN()

Activity 10.2.1.

Try the program below to see the error when N is 0.

🔗

Subsection 10.2.2 Traditional Error Handling

Obviously, the method in Listing 10.2.1 should not simply ignore the possibility that N might be 0. Listing 10.2.3 shows a revised version of the method, which includes code that takes action if the method’s precondition fails. Because there is no way to compute an average of 0 elements, the revised method decides to abort the program. Aborting the program appears to be a better alternative than returning 0 or some other default value (like

- 1

) as the method’s result and thereby allowing an erroneous value to spread throughout the program. That would just compound the error.

🔗

Principle 10.2.2. EFFECTIVE DESIGN:Unfixable Error.

If an unfixable error is detected, it is far better to terminate the program abnormally than to allow the error to propagate throughout the program.

🔗

Listing 10.2.3. One way to handle a divide-by-zero error might be to terminate the program, if there is an attempt to divide by 0, assuming it’s the kind of program that can be safely aborted. This version does not use exception handling.

🔗

/**
  * Precondition:  N > 0
  * Postcondition: avgFirstN() equals (1+2+...+N) divided by N
  */
public double avgFirstN(int N) {
    int sum = 0;
    if (N <= 0) {
      System.out.println(
           "ERROR avgFirstN: N <= 0. Program terminating.");
      System.exit(0);
    }
    for (int k = 1; k <= N; k++)
        sum += k;
    return sum/N;         // What if N is 0?
  } // avgFirstN()

The revised avgFirstN() method takes the traditional approach to error handling: Error-handling code is built right into the algorithm. If N happens to be 0 when avgFirstN() is called, the following output will be generated:

🔗

ERROR avgFirstN: N <= 0. Program terminating.

Activity 10.2.2.

Try the revised program below to see the error when N is 0.

🔗

Subsection 10.2.3 Java’s Default Exception Handling

To help detect and handle common runtime errors, Java’s creators incorporated an exception-handling model into the language itself. In the case of our divide-by-zero error, the Java Virtual Machine (JVM) would detect the error and abort the program. To see this, consider the program in Listing 10.2.4.

🔗

Activity 10.2.3.

Listing 10.2.4. Exception

🔗

Note that the avgFirstN() method is passed an argument of 0 in the CalcAvgTest.main(). When the JVM detects the error, it will abort the program and print the following message:

🔗

Exception in thread "main"
   java.lang.ArithmeticException:  / by zero
        at CalcAverage.avgFirstN(Compiled Code)
        at CalcAvgTest.main(CalcAvgTest.java:5)

The error message describes the error and provides a trace of the method calls, from last to first, that led to the error. This trace shows that the error occurred in the CalcAverage.avgFirstN() method, which was called by the CalcAvgTest.main() method.

🔗

As this example suggests, Java’s default exception handling is able to detect and handle certain kinds of errors and exceptional conditions. In the next section, we will identify what kinds of conditions are handled by the JVM.

🔗

Java, Java, Java: Object-Oriented Problem Solving, 2024E

Section 10.2 Handling Exceptional Conditions