• Exceptions:
  • Provide an alternative way for a method to return control
• Exception in Java:
  • Exceptions are handled using try and catch
  • Exceptions are thrown using throw
  • Exceptions are declared to be thrown (or re-thrown) using throws

• The Exception Hierarchy
• Creating Exception Classes
• Exceptions and Overriden Methods
• Chained Exceptions

• An Important Rationale for Specialization:
  Reduce code duplication
• The Additional Rationale Here:
  Categorization/classification of exceptions

• Purpose:
  • Only instances of this class (or its descendants) are thrown by the Java Virtual Machine or can be thrown by the Java throw statement
  • Only this class (or its descendants) can be the argument type in a catch clause
• Capabilities:
  • A snapshot of the execution stack (of its thread) at the time it was created
  • An optional message String
  • An optional cause (i.e., another Throwable that caused it to be thrown)

• Purpose:
  • An encapsulation of a serious problem that most applications should not try to handle
• Examples:
  • LinkageError
  • ThreadDeath
  • VirtualMachineError

• Purpose:
  • An encapsulation of a problem that most applications should handle
• Examples:
  • AWTException
  • InterruptedException
  • IOException
  • PrintException
  • RuntimeException (which is badly named since they are all are thrown at run-time)
  • ...

• The Situation:
  • Handling hieararchically related exceptions in the same way
• The Solution
  • The catch clause will be applied to any exception or specialization of exception (so you can catch multiple exceptions in one block if they are derived from the same class)

      try {
          //
      } catch (IOException ioe) { // FileNotFoundException, EOFException
          // Take appropriate action
      }
    

• The Situation:
  • Handling hierarchically related exceptions differently
• The Solution:
  • The derived exception must be caught first

      try {
          File f = new File("data.txt");
      } catch (FileNotFoundException fnfe) { // Derived Class
          // Take appropriate action
      } catch (IOException ioe) {            // Base Class
          // Take appropriate action
      }
    

• The Situation:
  • Handling unrelated exceptions in the same way
• The Solution:
  • Include a | between classes in the catch clause

      try {
          //
      } catch (IOException | SecurityException e) {
          // Take appropriate action
      }
    

• Unchecked:
  • Specializations of Error or RuntimeException
  • Occur within the Java runtime system (e.g., dividing by zero, pointer exceptions, indexing exceptions)
  • Do not need to be caught or specified (i.e., explicitly re-thrown) but can be
• Checked:
  • All others
  • Must be caught or specified (i.e., explicitly re-thrown) or a compile-time error will be generated

• When?
  • No existing exceptions are appropriate
  • It would be convenient if I could differentiate an exception from other exceptions
  • You throw several related exceptions and it would be nice to be able to group them (remember, catching a parent will catch all of the descendants)
• How?
  1. Choose a super class to extend
  2. Override the constructors

Handling Data Format Problems

javaexamples/exceptions/FormatException.java

import java.io.*;

/**
 * An IOException that is thrown when a "reader"
 * encounters an "input stream" that is not formatted properly
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class FormatException extends IOException
{
    /**
     * Default Constructor
     */
    public FormatException()
    {
        this("No details are available");
    }


    
    /**
     * Explicit Value Constructor
     *
     * @param message  Detailed information about the exception
     */
    public FormatException(String message)
    {
        super(message);
    }
}
        

javaexamples/exceptions/AddressTokenizer.java

import java.util.*;

/**
 * A class that can be used for tokenizing strings
 * that contain address information
 *
 * This class assumes that each String contains a name and
 * an email address (with a comma between them)
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class AddressTokenizer
{

    /**
     * Default Constructor
     *
     */
    public AddressTokenizer()
    {
        super();
    }


    /**
     * Tokenize a Sring and return the email address it contains
     *
     * @return   The email address
     */
    public String tokenize(String line) throws FormatException
    {
        FormatException       exception;
        int                   count;
        String                address, name;
        StringTokenizer       tokenizer;


        // Count the tokens
        tokenizer = new StringTokenizer(line,",");
        count     = tokenizer.countTokens();

        // Parse the line (checking the format along the way)
        if (count != 2)
        {
            exception = new FormatException("Missing , in line: "+
                                            line);
            throw exception;
        }
        else
        {
            name    = tokenizer.nextToken();
            address = tokenizer.nextToken();

            if (address.indexOf("@") < 0)
            {
                exception = new FormatException("Missing @ in line: "+
                                                line);
                throw exception;
            }
        }


        return address;
    }
}
        

javaexamples/exceptions/AddressDriver.java

import java.io.*;

/**
 * A class that illustrates the use of the AddressTokenizer
 * and FileFormatException classes
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class AddressDriver
{
    /**
     * The entry point
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args)
    {
        AddressTokenizer       spammer;
        int                    i;
        String                 email;

        spammer = new AddressTokenizer();

        try {

            for (i=0; i < args.length; i++)
            {
                email = spammer.tokenize(args[i]);

                // Send spam to this email address
            }
        }
        catch (FormatException ffe)
        {
            System.out.println(ffe.getMessage());
        }
    }
}
        

• The Situation:
  • Suppose a method that explicitly throws one or more exceptions is overriden in a derived class
• Issues:
  • The method in the derived class cannot throw more checked exceptions than the method it is overriding
  • The method in the derived class can throw an exception that is derived from the declared exception (e.g., a EOFException can be thrown when the declared exception is a IOException )

• Purpose:
  • Allow you to re-throw an exception and provide additional information (without losing the original cause or stack trace)
• Adding to the Chain:
  • Use the Throwable(java.lang.Throwable) constructor
  • Use the Throwable.initCause(java.lang.Throwable) method