Learning Objectives

Unchecked (Runtime) Exceptions

• An unchecked exception is usually the result of a programming error
• For example, consider the example:

  String str = null;
  System.out.println(str.length());
  

• This code will cause a NullPointerException
• There is nothing that the program can do to recover from this error
• The programmer needs to go back and fix the code
  
• Thus, a NullPointerException was written as an unchecked exception
• The compiler does not ensure there is a handler for unchecked exceptions built into the code
  
• If an unchecked exception does not have an error handler, the general exception handler is used
• The general exception handler produces a stack trace and then exits the program
• Note in the below diagram that exceptions with RuntimeException as an ancestor are unchecked
  • Otherwise, they are checked exceptions

Predefined Exception Classes

• As we have seen, there are more exception classes than the single class Exception
• Some of them are shown in the following tree
• You can also write your own exceptions, which we will cover in the following section
• However, you should use standard exceptions wherever possible

java.lang.Throwable
  |
  +--java.lang.Error (Unchecked)
  |
  +--java.lang.Exception (Checked)
       |
       +--java.lang.InterruptedException
       |
       +--java.io.IOException
       |
       +--java.lang.RuntimeException (Unchecked)
            |
            +--java.lang.ArithmeticException
            |
            +--java.lang.IllegalArgumentException
            |
            +--java.lang.IllegalStateException
            |
            +--java.lang.IndexOutOfBoundsException
            |
            +--java.lang.NullPointerException
            |
            +--java.util.NoSuchElementException
               |
               +--java.util.InputMismatchException

• Throwable is the root class of all exceptions
  • Has the commonly used methods for all errors and exceptions
• Error means that a serious problem has occurred
  • Applications cannot recover from these types of problems
• Exception is the root class of exceptions that a reasonable program might catch
• RuntimeException are errors caught by the JVM rather than the compiler
  • Usually due to program bugs
• All exceptions other than Error and RuntimeException (and subclasses) are checked exceptions
  • The compiler forces you to deal with the exception
• Predefined exceptions usually include a meaningful message that is retrieved with method getMessage():

  System.out.println(e.getMessage());

What Exceptions Can Occur?

• The are two usual ways to determine what exceptions can occur in a program
• The first way is to try the code and see what happens
• If we tried to code our TotalCalculator program without a try-catch:

  Scanner input  = new Scanner(System.in);
  double cost = 0, tax = 0;
  
  System.out.print("Enter cost: ");
  cost = input.nextDouble();
  System.out.print("Enter tax: ");
  tax = input.nextDouble();
  double total = cost + tax;
  System.out.println("Total: " + total);
  System.out.println("Thanks for paying!");
  

• We found we could get a an exception like:

Enter cost: $100
Exception in thread "main" java.util.InputMismatchException
      at java.util.Scanner.throwFor(Scanner.java:840)
      at java.util.Scanner.next(Scanner.java:1461)
      at java.util.Scanner.nextDouble(Scanner.java:2387)
      at TotalCalculator1.main(TotalCalculator1.java:9)

• This tells you that you need to code a try-catch for an InputMismatchException
• Sometimes you might want to know what the possible exceptions are possible in your code
  
• To find out, you can look up exceptions in the Java API
• For example, you can look up the documentation for the Scanner method: nextDouble()
• You then examine the list of possible exceptions and determine if and how they might occur in your program

• Catching and Handling Exceptions
• The try Block
• The catch Blocks

Using the throws Clause

• Anytime your program uses a method that can cause a checked exception or throws an unchecked exception, your program must do something with it.
• You have two options:
• Handle the exception using a try-catch
• Throw the exception to another method or to the general exception handler
  
• If you decide the method cannot handle the exception, you use a throws clause to send the exception to the caller
• The general syntax for throwing an exception:

  [accessModifier] returnType methodName(parameterList)
      throws ExceptionType1, ExceptionType2,... {
      // statements
  }
  

• Where:
  • accessModifier: determines which classes can access this method
  • returnType: the type of value returned by the method, or void for no return value
  • methodName: the name you make up for the method
  • parameterList: the types and names of the parameters
  • ExceptionTypeX: the type of exception a method throws
• For example:

  
  public void printArrayFile(File f) throws IOException {
      PrintWriter pw = new PrintWriter(f) 
      for (int i = 0; i < numElements; i++) {
          pw.println(array[i]);
      } pw.close();
  
  }

• Throwing an exception is like passing the buck:
  • Requires the calling method to deal with the exception
• The calling method can also throw the exception
• Eventually some method should catch it or the general exception handler is called

How Exceptions are Propagated

• When methods cannot handle an exception, that method should throw the exception
• The user of the method can then decide how to handle the exception
• Methods can call other methods that can throw an exception
• This chain continues usually until one method catches the exception
• If no method catches the exception, then the general exception handler will print an error message at runtime.
  

Example of Exception Propagation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 

public class ExceptionPropogation {

    public static void main(String[] args) {
        methodD();
    }

    public static void methodD() {
        try {
            methodC();
        } catch (Exception e) {
            System.out.println("Caught exception in D");
            System.out.println(e.getMessage());
        }
    }

    public static void methodC() throws Exception {
        methodB();
    }

    public static void methodB() throws Exception {
        methodA();
    }

    public static void methodA() throws Exception {
        throw new Exception("Throwing exception in A");
    }
}

Throwing Exceptions

• You may be wondering how the code in Scanner and other classes generates an exception
• The answer is the Java throw statement
• Syntax:

  throw new ThrowableObject

• Where:
  • ThrowableObject: the exception class to throw
• For example:

  throw new Exception("Exception message");

• Note that throw is a Java keyword, which should be followed by an Exception object.
• In the above example, throw is followed by a call to the Exception constructor
  
• Typically, you decide to throw an exception after checking for an error condition:

  if (cost < 0) {
      throw new Exception(
          "Cost cannot be less than 0");
  }
  

• To demonstrate, let us throw an exception in an example program

Example Program Using throw

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36 

import java.util.Scanner;
import java.util.InputMismatchException;
import java.util.NoSuchElementException;

public class TotalCalculator {
	public static void main(String[] args) {
        Scanner input  = new Scanner(System.in);
        double cost = 0, tax = 0;

        boolean more = true;
        while (more) {
            try {
                System.out.print("Enter cost: ");
                cost = input.nextDouble();
                if (cost < 0) {
                    throw new Exception(
                        "Cost cannot be less than 0");
                }
                System.out.print("Enter tax: ");
                tax = input.nextDouble();
                if (tax < 0) {
                    throw new Exception(
                        "Tax cannot be less than 0");
                }
                double total = cost + tax;
                System.out.println("Total: " + total);
                more = false;
            } catch(Exception e) {
                String message = e.getMessage();
                System.out.println(message);
                input.nextLine(); // clear the buffer
            }
        }
        System.out.println("Thanks for paying!");
    }
}

• Note the use the getMessage() method to explain the error
• There are a few other commonly used exception methods shown in the table below
• Note that the line of code above to clear the buffer is not strictly necessary here as the tax value has already been read into the variable before throwing the exception.
• However, in the prior example, it was required to clear the erroneous input from the buffer, which we were not able to read into the variable:

           try {
                System.out.print("Enter cost: ");
                cost = input.nextDouble(); //a String cannot be read into this variable
                System.out.print("Enter tax: ");
                tax = input.nextDouble(); //a String cannot be read into this variable
                double total = cost + tax;
                System.out.println("Total: " + total);
                more = false;
            } catch(InputMismatchException e) {
                System.out.println(
                    "Error -- enter digits only!");
                input.nextLine(); // clear the buffer (required)
            }

When to Throw an Exception

• Your program should only throw exceptions for exceptional conditions
• This may happen when a method encounters a situation where it cannot complete its task
• For example: the wrong file name was passed to the method opening a file
• Throw an exception to the calling method, which can ask the user for the correct name

Activity 16.2: More Scores (10 pts)

• When your program is working as shown, submit Scores.java to Canvas.