Programming Languages‎ > ‎Java‎ > ‎

10. Java Exceptions

What is an Exception?

  • When a problem occurs, Java attempts to transfer control to a method that can deal with the problem, called exception handlers.  An exception handler can either correct the problem (fault handlers), gracefully terminate the program (trap handlers), or simply ignore the problem.  However, if there is no exception handler and an exception occurs, then the appropriate error messages are displayed and the program is terminated.

Types of Problems: errors and exceptions

  • Exceptions can be further divided into I/O exceptions and runtime exceptions:
  • I/O exceptions occur when bad things happen to an otherwise good program, such as trying to open a file that doesn't exist.
  • Runtime exceptions are programming errors, such as a bad cast, an out-of-bounds array access, or a null pointer access.
  • Errors are system errors, such as memory exhaustion.  Programmers should not attempt to handle these.

Throwable is the superclass for all exceptions & errors.

The Exception and Error classes are organized in a hierarchy of subclasses. 

For example:

  • java.lang.Exception class has as one of its subclasses java.lang.RuntimeException
  • java.lang.RuntimeException class has as one of its subclasses java.lang.IndexOutOfBoundsException
  • java.lang.IndexOutOfBoundsException class has as one of its subclasses java.lang.ArrayIndexOutOfBoundsException

This allows the program to catch the specific ArrayIndexOutOfBoundsException, and/or any of its superclasses IndexOutOfBoundsException, RuntimeException or Exception.  The more general the exception (higher in the hierarchy), the more subclass exceptions could be caught, but handling them properly would require more work. 



Catching an Exception

  • To handle an exception explicitly or implicitly thrown by a method, the method call must be called inside a try block.  The handler code is placed in an immediately following try block in a catch clause.
  • Syntax for try block:
try {
  // statements monitored for exceptions
}
catch( exception-class obj-reference ){
  // statements that handle exception
}
/* There may be more than one catch clause if more than one exception is caught */
  • NOTE: An exception does NOT need to be caught in the method that triggers the exception.  In fact, it's often better to catch and handle the exception in one of the calling methods (further down the call stack).
  • Suggestion: Include inside the try block (after the code that may throw an exception) the statements to be executed IF there is NO exception!  This eliminates the need to check after the catch clauses if it worked or not.

Example:

//be sure to import java.util.* for ArrayList
ArrayList<String> list = new ArrayList<String>();
String str;  int i; boolean errorOccurred;
// other code may be here
do {
          errorOccurred = false;
          try{
                    // code here to assign to i
                    str=list.get(i);// might throw an exception
                    // put code here for when there's NO exception
          }
          catch(IndexOutOfBoundsException exp){ 
                    errorOccurred=true;
                    System.err.println("Exception: " + exp);
                    // should do more to "handle" the exception here
          } // end catch exception

}while( errorOccurred);
  • In the above example, if the IndexOutOfBoundsException is thrown from ANY method inside the try block, a reference to the exception object will be passed to exp and execution will transfer to the block with the catch clause.
    • NOTE: You do not have to match every type of exception that is thrown (implicitly or explicitly) in the try block with a catch clause.  Include a catch clause for the exception(s) you want to handle for this try block.

Another Exception Example and "finally"

  • You may catch a specific exception and more than one exception, but the more specific exceptions MUST be put before the more general exceptions, for example
// This is inside some method
int intCh;
char ch;
try {
          System.out.println("Enter a character: ");
          intCh = System.in.read(); // may throw IOException
          ch = (char) intCh;
          .
          .
          .
}// end try
catch( IOException ex ){// may be other statements here
          System.err.println(ex); // calls toString on ex
} // end catch IOException
catch( Exception ex ){
          System.err.println(ex);
} // end catch Exception

 

finally clause:

  • A finally clause is executed whether or not an exception is thrown
  • A finally clause is executed even if there's a return statement before it
  • A finally clause is used when we must guarantee the some cleanup code is executed
  • A finally clause follows any catch clauses and has the syntax:

finally {
          // cleanup statements
}

  • A finally clause is optional if you have at least one catch clause, but required if you don't have any catch clauses at the end of a try block
  • Example (after the ArrayList try block on the previous page):

finally {  str = null; list = null; }


When to Catch an Exception

  • You MUST catch an exception (i.e., call the method in a try block and include a catch clause for the exception) if you call a method defined with the throws clause, for example

public abstract int read() throws IOException { . . .}
unless your method also is defined with the throws clause for the same exception(s) that the called method throws (more on throws clause on the next page)

  • You SHOULD catch an exception if an exception may occur in your program (for example, an ArrayIndexOutOfBoundsException)

/*
Exercise 10.1 - Determine which exception will be thrown by the Scanner class' nextInt or nextDouble methods.  
Change a previously written Java program that reads numeric input from the user.  
Call the input method in a try block and catch the specific exception that the input method would throw 
if the user entered non-numeric input. Allow the user to input the number again if an exception is caught. 
Suggestion: DON'T use recursion, but put the try block and catch clause inside a loop, using a boolean variable that will be tested in the loop condition.
 */

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

public class Exercise_10_1_Exception
{
static Scanner oScanner = new Scanner(System.in);
private int i_Total = 0;

public boolean inputMethod()
{
boolean isError = false;
try // Comments: Score deduction - should put try catch inside loop
{
for(int i = 0; i < 5; i++)
{
System.out.println("Enter integer number to sum");
i_Total = i_Total + oScanner.nextInt();
}
}
catch(InputMismatchException ex)
{
isError = true;
i_Total = 0;
}
return isError;
}
public static void main( String[] args )
{
Exercise_10_1_Exception oException = new Exercise_10_1_Exception();
// Catch java.util.InputMismatchException for oScanner.nextint()
boolean isException = oException.inputMethod();
if(!isException)
System.out.println("Total = " + oException.i_Total);
else
System.out.println("Exception: Invalid integer");
} // end main
} // end class Exercise_10_1_Exception


Throwing Exceptions

  • When should your program throw an exception? There are many methods in which bad input or invalid parameter values are impossible to handle (for example, in a constructor). In these cases, it's best to have these methods/constructors throw an exception.
  • Define your method with the throws clause, which is given after the right-parenthesis of the parameter list and has the syntax: throwsexception-list
for example,
public void someMethod( int i )
      throws IOException, MyException{
. . . 
} 
// MyException is a subclass of Exception that you write
  • Inside the method that throws the exception(s), when an error occurs (usually detected with an if statement), create an instance of an exception (passing an argument which describes the exception) and pass it in the throw statement, which has the syntax:

          throw(exObj);

  • for example:
if( myExceptOccurred ){
     MyException ex = 
              new MyException("MyException Occurred");
     throw( ex );
}
  • Throwing an exception causes control to return immediately to the calling method, which either handles the exception or implicitly throws the exception to its calling method.

NOTE ABOUT WHERE TO THROW AND CATCH EXCEPTIONS:  The reason for throwing an exception is to allow another method handle the exception, different from the method where the error occurred.  Therefore, it's a bad idea to throw an exception and include a corresponding catch clause in the same method as the throw statement.  If you want to handle an error inside the same method, just use if-else statements.


Exception Exercises

/*
Exercise 10.2: 
Change any class from a previous exercise or programming homework assignment to throw an exception 
if the input or parameter is out of range.  Write a driver application program that catches that exception, 
but continues (after handling the exception, may loop).  Make sure the catch clause is not in the same method 
as the throw statement.
 */
// Note: Modified exercise 2.4 to get cube using square function (Not a good example but just to demonstrate concept)

import java.io.*;
import java.util.Scanner;

public class Exercise_10_2_ThrowException
{
static Scanner oScanner = new Scanner(System.in);
public static void main(String[] args) 
{
int i_num;
int i_cube;
for(int i = 0; i < 5; i++)
{
System.out.println("Enter number to get cube (-500 to 500 range)");
i_num = oScanner.nextInt();
i_cube =  getCube(i_num);
if(i_cube == -1000)
System.out.println("Error in getCube(), continue with next number.");
}
System.out.println("Main Ends");
}
public static int getCube(int i)
{
int i_cube = 0;
try
{
i_cube = i * getSquare(i);
System.out.println("Cube: " + i_cube);
}
catch(IOException e)
{
System.err.println("Error: " + e);
i_cube = -1000; // sample indicator
}
return i_cube;
}
public static int getSquare(int i) throws IOException
{
IOException oIOException = new IOException("Number is out of range");
if(i >= -500 && i <= 500)
return i * i;
else
throw(oIOException);
}
}


Class Hierarchy of Exceptions and Errors

class java.lang.Throwable (implements java.io.Serializable) 
      class java.lang.Error
             class java.lang.LinkageError
                     class java.lang.ClassCircularityError
                     class java.lang.ClassFormatError
                          class java.lang.UnsupportedClassVersionError
                     class java.lang.ExceptionInInitializerError
                     class java.lang.IncompatibleClassChangeError
                          class java.lang.AbstractMethodError
                          class java.lang.IllegalAccessError
                          class java.lang.InstantiationError
                          class java.lang.NoSuchFieldError
                          class java.lang.NoSuchMethodError
                     class java.lang.NoClassDefFoundError
                     class java.lang.UnsatisfiedLinkError
                     class java.lang.VerifyError
             class java.lang.ThreadDeath
             class java.lang.VirtualMachineError
                     class java.lang.InternalError
                     class java.lang.OutOfMemoryError
                     class java.lang.StackOverflowError
                     class java.lang.UnknownError
             class java.awt.AWTError
      class java.lang.Exception
             class java.lang.ClassNotFoundException
             class java.lang.CloneNotSupportedException
             class java.lang.IllegalAccessException
             class java.lang.InstantiationException
             class java.lang.InterruptedException
             class java.lang.NoSuchFieldException
             class java.lang.NoSuchMethodException
             class java.lang.RuntimeException
                     class java.lang.ArithmeticException
                     class java.lang.ArrayStoreException
                     class java.lang.ClassCastException
                     class java.lang.IllegalArgumentException
                          class java.lang.IllegalThreadStateException
                          class java.lang.NumberFormatException
                     class java.lang.IllegalMonitorStateException
                     class java.lang.IllegalStateException
                          class java.awt.IllegalComponentStateException
                     class java.lang.IndexOutOfBoundsException
                          class java.lang.ArrayIndexOutOfBoundsException
                          class java.lang.StringIndexOutOfBoundsException
                     class java.lang.NegativeArraySizeException
                     class java.lang.NullPointerException
                     class java.lang.SecurityException
                     class java.lang.UnsupportedOperationException
            class java.awt.AWTException
            class java.io.IOException
                     class java.io.CharConversionException
                     class java.io.EOFException
                     class java.io.FileNotFoundException
                     class java.io.InterruptedIOException
                     class java.io.ObjectStreamException
                          class java.io.InvalidClassException
                          class java.io.InvalidObjectException
                          class java.io.NotActiveException
                          class java.io.NotSerializableException
                          class java.io.OptionalDataException
                          class java.io.StreamCorruptedException
                          class java.io.WriteAbortedException
                     class java.io.SyncFailedException
                     class java.io.UnsupportedEncodingException

class java.io.UTFDataFormatException


Exception Handling Example Program

  • This program tries to convert a String from a JTextField into an int.  If it fails, an exception is caught and handled in this program.  Note that if the [Enter] key is pressed while the cursor is in a JTextField (or TextField), an ActionEvent occurs.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExceptionHandlingExample extends JFrame
                         implements ActionListener{
      private String str;
      private JTextField tf1, tf2;
      private int sum=0;

      public ExceptionHandlingExample(){
            super("Exception Handling Example");
            setLayout(new FlowLayout());
            str = ""; 
            tf1= new JTextField(10);
            tf1.addActionListener(this);  
            tf1.setVisible(true);
            tf1.setEditable(true);// default
            tf2=new JTextField(30);
            tf2.setEditable(false);
            
            add(new JLabel("Enter a number and press [Enter] "));
            add(tf1);
            add(tf2);

      } // end constructor

      public void actionPerformed(ActionEvent e){
            int inputInt=0;
            try {
                  inputInt = Integer.parseInt(tf1.getText());
                  sum += inputInt;
                  tf2.setText("Sum is now "+ sum);
            } // end try
            catch( NumberFormatException nfe ){
                  JOptionPane.showMessageDialog(null, "Must enter digits only!",
                        "Input Error",    JOptionPane.ERROR_MESSAGE);
            } // end catch 
            tf1.setText("");
      }

      public static void main( String[] args ){
            ExceptionHandlingExample fp =new ExceptionHandlingExample();
            fp.setSize(400, 200);
            fp.setVisible(true);
            fp.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      } // end main

} // end class ExceptionHandlingExample


Exception Throwing Example

  • The following program computes and displays sqrt3(x) for x = 16 and x = -16.  In the second case, the attempt to compute sqrt3(-16) throws a custom "negative number" exception, which is handled by the caller of the caller (jumps 2 methods).  Here, we defined our own exception class (isn't necessary, this is just an example of creating your own Exception class):

import java.io.*;

public class NegativeNumberException extends IOException{

public NegativeNumberException(double irritant){
     super("non-negative number expected, not " 
                   + irritant);
}

public NegativeNumberException(){
      super("non-negative number expected");
}

} // end NegativeNumberException class

// in a separate file:
public class ExceptionDemo{


public static double squareRoot(double x)
                                            throws NegativeNumberException{

System.out.println("Entering squareRoot()");
if (x < 0){
      NegativeNumberException exp
         = new NegativeNumberException(x);
      throw(exp);
}
System.out.println("Exiting squareRoot()");
return Math.sqrt(x);

}

public static double cubeOfSquareRoot(double x)
                                                      throws NegativeNumberException{

System.out.println("Entering cubeOfSquareRoot()");
double temp =
          squareRoot(x); // may implicitly throw exception here
System.out.println("Exiting cubeOfSquareRoot()");
return temp * temp * temp;

}

public static void displayCubeOfSquareRoot(double x)
{

double result = 0;
System.out.println(
              "Entering displayCubeOfSquareRoot()");
try{
      result = cubeOfSquareRoot(x);
      System.out.println("result = " + result);
 }catch(NegativeNumberException e){
      System.err.println("Error: " + e);
      // more steps here?
}
System.out.println(
              "Exiting displayCubeOfSquareRoot()");

}

public static void main(String[] args){

System.out.println("Entering main()");
System.out.println(
              "calling displayCubeOfSquareRoot(16)");
displayCubeOfSquareRoot(16);
System.out.println
              ("calling displayCubeOfSquareRoot(-16)");
displayCubeOfSquareRoot(-16); // trouble
System.out.println("Exiting main()");

} // end main

} // ExceptionDemo


Comments