• The Problem:
  • Your method can't handle the values its been given
• One Example:
  • A calculation that results in a negative price
• One Solution:
  • Return a "special value"

An Example that Uses a Special Value

javaexamples/exceptions/PriceCalculator.java

/**
 * A simple PriceCalculator
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class PriceCalculator
{
    private double[] discounts = {0., 1., 5., 20., 100.};


    /**
     *  Apply a quantity-based discount
     */
    public double applyDiscount(double price, int quantity)
    {
        double       discountedPrice;
        int          i;

        discountedPrice = price;

        // Find the discount and adjust the price;
        i = discounts.length - 1;
        while (i >= 0)
        {
            if (quantity >= i)
            {
                discountedPrice = price - discounts[i];
                break;
            }

            --i;
        }

        // Return -1 to indicate a problem
        if (discountedPrice < 0) discountedPrice = -1;

        return discountedPrice;
    }

}
        

• What "special value" would you return for a method that fails while converting a String into a double?
  • Since all double values are legitimate return values there is no special value that can be used.
• Is it always safe to return a "special value"?
  • No because you have to rely on the caller behaving properly in response (e.g., check for -1 in the previous example).
• What else might we do to "signal" the caller that a special situation has arisen?
  • One could use an alternative return mechanism.

• Returning from Within a Method:
  • Normal Return - drop out of the method or use a return statement (with or without a value to return)
  • Alternative Return - Use a throw statement (which must pass back a Throwable object)
• Handling a Return from a Method:
  • Normal Return - The method evaluates to the returned value (which can be used in an expression like any other value) and processing continues
  • Alternative Return - The caller must indicate what code should be executed on return (and how the Throwable should be used)

• Normal Return:
  • The declaration of the method includes a return type (or void)
• Alternative Return:
  • The declaration of the method includes a throws clause (that specifies the exception)

In the following example, a throw statement is used for an alternative return and the return statement is used for a normal return.

javaexamples/exceptions/EmailAddress.java (Fragment: getHost)

    /**
     * Return the host portion of an email address
     *
     * @param  address   A String representation of an email address
     * @return The host portion of the email address
     */
    public static String getHost(String address) throws IllegalArgumentException
    {
       int     index;
       
       index = address.indexOf("@");
       if ((index <= 0) || (index >= address.length()-1))
       {
          throw new IllegalArgumentException("Misplaced or missing @.");
       }
       else
       {
          return address.substring(index+1);
       }

       // Note: This is equivalent to:
       //
       // if ((index <= 0) || (index >= address.length()-1))
       // {
       //     throw new IllegalArgumentException("Misplaced or missing @.");
       // }
       //
       // return address.substring(index+1);
    }
        

• Normal Return:
  • A try block is used to indicate the code that should be executed when the method returns normally
• Alternative Return:
  • A catch block (which is passed a Throwable) is used to indicate the code that should be executed when the method returns "abnormally"

• Syntax :
  • try {statement...} catch(exception name) {[statement]...}
• Including the finally Clause:
  • try {statement...} [catch(exception name) {[statement]...}] finally {[statement]...}
  • The finally block is executed regardless of which try or catch block is executed.

Continuing the Earlier Example

javaexamples/exceptions/EmailProcessor.java

/**
 * A simple application that prints the host associated with an
 * email address
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class EmailProcessor
{
    /**
     * The entry-point of the application
     *
     * @param args  The command-line arguments
     */
    public static void main(String[] args)
    {
       String      host;
       
       if ((args != null) && (args.length > 0))
       {
          try
          {
             host = EmailAddress.getHost(args[0]);
             System.out.println("Host: "+host);
          }
          catch (IllegalArgumentException iae)
          {
             System.out.println("Try another email address!");
          }
       }
    }
}
        

An Example with a Loop

javaexamples/exceptions/GradeProcessor.java

/**
 * A simple application that prompts the processes 
 * grades (provided as command line arguments)
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class GradeProcessor
{
    /**
     * The entry-point of the application
     *
     * @param grades  The space-delimited grades
     */
    public static void main(String[] grades)
    {
       double         total;
       final double   DEFAULT = 50.0;       


       total = 0;       
       for (int i=0; i<grades.length; i++)
       {
          try
          {
             total += Double.parseDouble(grades[i]);
          } 
          catch (NumberFormatException nfe)
          {
             total += DEFAULT;
          }
       }

       System.out.printf("Average: %3.1f", total/grades.length);       
    }
}
        

• An Example:
  • catch(NumberFormatException nfe) { total += DEFAULT; }
• What's Going On?
  • An operation or method is going to "throw" a NumberFormatException object that this statement is going to "catch" and name nfe.
  • This is not unlike a method with a single formal parameter.

Bonding

(Courtesy of xkcd)

• An Observation:
  • A particular method may not be able to handle the "abnormal" return
  • Example: When a method that does a calculation would need to prompt for another input
• An Alternative to try-catch
  • Re-throw the exception (i.e., "let someone else handle it") and specify that this is the case (i.e., include a throws clause in the declaration)

An Example

javaexamples/exceptions/Divider.java

/**
 * A simple utility class for integer division that
 * illustrates how exceptions can be re-thrown
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class Divider
{
    /**
     * Performs integer division
     *
     * @param num   The numerator
     * @param denom The denominator
     * @return      The result of the integer division
     * @throws      An ArithmeticException in case of a divide by zero
     */
    public int divide(int num, int denom) throws ArithmeticException
    {
        int     result;

        result = num / denom;
        return result;
    }
}
        

An Example

javaexamples/exceptions/DividerDriver.java

/**
 * A simple application that sequentially divides 
 * elements in an array.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class DividerDriver
{
    public static void main(String[] args)
    {
       Divider    d;
       int        i, ratio;
       int[]      numbers = {100,10,0,5,2,8,0,30};


       d = new Divider();

       for (i=0; i < numbers.length-1; i++) 
       {
          try 
          {
             ratio = d.divide(numbers[i], numbers[i+1]);
             System.out.println(numbers[i]+"/"+numbers[i+1]+"="+ratio);
          } 
          catch (ArithmeticException ae)
          {
             System.out.println("Couldn't calculate "+
                                numbers[i]+"/"+numbers[i+1]);
          }
       }
    }
}
        

• A Design Question:
  • I'm calling a method that can throw an exception. Should I catch it or re-throw it?
• The General Answer:
  • If "you" can handle the exception (e.g., use a default value or correct the mistake) then "you" should
  • Otherwise, assume that whoever called "you" will know how to handle it and re-throw it

• "Never" Print in a catch Block:
  • If the application uses the console, the message will interrupt the normal flow of the user interface
  • If the applications doesn't use the console (e.g., uses a GUI), the message will be lost
• What About Debugging?
  • While debugging it is often helpful to temporarily print in catch blocks (but it is better to use a logger)
• What About main()?
  • In small applications it is sometimes permissible to print in catch blocks that are in the main() method

Beginning programmers often make the following mistake when told that a method must throw an exception. For example, if they are told that the method they are writing must throw a NumberFormatException they add a throws NumberFormatException clause to the method declaration and do the following.

  try
  {
      d = Double.parseDouble(s);
  }
  catch (NumberFormatException nfe)
  {
      throw new NumberFormatException(); // throw nfe; is also bad
  }
  

Instead you should add a throws NumberFormatException clause to the method declaration and do the following.

  d = Double.parseDouble(s);
  

The only reason to include a throw statement in a catch block is if a different exception must be thrown.

The following two fragments have very different behavior.

javaexamples/exceptions/NestedBlockExample.java (Fragment: 0)

       for (i=0; i < args.length; i++)
       {
          try
          {
             value = Double.parseDouble(args[i]);
             System.out.println(args[i]+" is a number");
          } 
          catch (NumberFormatException nfe)
          {
             System.out.println("Not a number");
          }
       }
        

javaexamples/exceptions/NestedBlockExample.java (Fragment: 1)

       try 
       {
          for (i=0; i < args.length; i++) 
          {
             value = Double.parseDouble(args[i]);
             System.out.println(args[i]+" is a number");
          }
       } 
       catch (NumberFormatException nfe)
       {
          System.out.println("Not a number");
       }
        

• A Question:
  • Can a method return "abnormally" in more than one way?
• The Answer:
  • Yes, a method can throw more than one exception
• The Caller:
  • Can catch multiple exceptions
  • Can catch some exceptions and re-throw others

An Example

javaexamples/exceptions/Calculator.java

/**
 * A simple calculator.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class Calculator
{
    /**
     * The entry point of the application.
     *
     * @param args  Syntax: left-operand operator right operand
     */
    public static void main(String[] args)
    {
       char           operator;
       int            left, result, right;

       try 
       {
          result = 0;

          left  = Integer.parseInt(args[0]);
          right = Integer.parseInt(args[2]);

          operator = args[1].charAt(0);
            
          switch (operator) 
          {
             case '+': 
                result = left + right;
                break;

             case '-': 
                result = left - right;
                break;

             case '/': 
                result = left / right;
                break;
          }
          System.out.println("Result: "+result);
       } 
       catch (ArithmeticException ae) 
       {
          System.out.println("Does not compute!");
       } 
       catch (NumberFormatException nfe) 
       {
          System.out.println("Non-numeric operand!");
       }
    }
}
        

• A Question:
  • Can you tell which call to parseInt generated the exception in the previous example?
• Handling These Situations:
  • You can nest try-catch statements

An Example

javaexamples/exceptions/CalculatorNested.java

/**
 * A simple calculator.
 *
 * This version illustrates how try-catch blocks can be nested.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 2.0
 */
public class CalculatorNested
{
    /**
     * The entry point of the application.
     *
     * @param args  Syntax: left-operand operator right operand
     */
    public static void main(String[] args)
    {
       char           operator;
       int            left, result, right;

       result = 0;
       
       try
       {
           left  = Integer.parseInt(args[0]);
           try
           {
               right = Integer.parseInt(args[2]);
               operator = args[1].charAt(0);

               try
               {
                   switch (operator) 
                   {
                       case '+': 
                           result = left + right;
                           break;
                           
                       case '-': 
                           result = left - right;
                           break;
                           
                       case '/': 
                           result = left / right;
                           break;
                   }
                   System.out.println("Result: "+result);
               } 
               catch (ArithmeticException ae) 
               {
                   System.out.println("Does not compute!");
               } 
           }
           catch (NumberFormatException rnfe)
           {
               System.out.println("Right-side operand is non-numeric!");
           }
       }
       catch (NumberFormatException lnfe) 
       {
           System.out.println("Left-side operand is non-numeric!");
       }
    }
}
        

• Debugging:
  • All Exception objects have a printStackTrace() method that can be used during debugging (but only during debugging)
• The main() Method
  • The main() method can re-throw exceptions
  • If it does, the application will terminate

• The Exceptions:
  • ArithmeticException
  • IndexOutOfBoundsException
  • NegativeArraySizeException
  • NullPointerException
• The Result:
  • In the past, an exception caused your application to terminate
  • Now you know you can catch or re-throw it

• A Common Mistake:
  • Beginning programmers often catch or re-throw exceptions without thinking (e.g., "The submissions system says there's an ArrayIndexOutOfBoundsException so I'll fix it by adding a try-catch block.")
• An Important Guideline:
  • Don't use exception handling where other techniques can be applied easily (e.g., don't attempt to access a non-existent element of an array)

• Types of Exceptions:
  • Unchecked (Descendants of RuntimeException ) - Need not be caught or specified/re-thrown
  • Checked (Other descendants of Exception ) - Must be caught or specified/re-thrown
• What This Means:
  • If you call a method that throws a checked exception you must either catch it or re-throw it
  • A method that throws a checked exception must have a throws clause in its declaration

• Visualization:
  • Include {exceptions=name[,...]} after the return type of the method to indicate that exceptions are thrown
• An Observation:
  • You may or may not include the exception classes in the diagram (as needed)