CS2312 Lecture 8

Exceptions

An exception or exceptional event is an event that occurs during the execution of a program that disrupts the normal flow of instructions.

The following will cause exceptions:  

• Accessing an out-of-bounds array element  
• Writing into a read-only file  
• Trying to read beyond the end of a file  
• Sending illegal arguments to a method  
• Performing illegal arithmetic (e.g divide by 0)  
• Hardware failures  

When an exception occurs, we say it was thrown or raised

When an exception is dealt with, we say it is handled or caught

The block of code that deals with exceptions is known as an exception handler 

public class ArrayExceptionExamole{
    public static void main(String args[]){
        String[] names = {"xxx","XXX"};
        System.out.println(names[2]);
    }
}

// The println in the above code causes an exception to be thrown with the following exception message:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2 at
ArrayExceptionExample.main(ArrayExceptionExample.j ava:4)

Exception class: java.lang.ArrayIndexOutOfBoundsException

Array index that is out out of bounds: 2

Method throws the exception: ArrayExceptionExample.main

File contains the method:  ArrayExceptionExample.java

Line of the file throws the exception: 4

 

Throwing Exceptions

Use the throw statements to throw an exception

if (student == null)
    throw new NullPointerException();

throw statement requires a single argument: a Throwable object

Throwable objects are instances of any subclass of the Throwable class. 

 

Handling Exceptions

Use a try-catch block to handle exceptions that are thrown

try{
    // code that might throw exception
} catch([Type of Exception] e){
    // what to do if exception is thrown
} catch(ExceptionType<1> e1){
    // what to do if exception is thrown
} catch(ExceptionType<2> e2){
    // what to do if exception is thrown
}catch(ExceptionType<3>e3){
     // what to do if exception is thrown
}

// 1. try {} block may have one or multiple statements.
// 2. try{} block may throw a single type of Exception or multiple exceptions. But at a time it can throw only single type of exception.
// 3. There can be multiple catch() { .. } blocks associated with single try{} block.
// 4. If try{} block can throw multiple exceptions then user should catch all exceptions. (one catch block for each type of exception)

Example:

package exceptions;

class ExceptionDemo
{
    public static void main(String args[])
    {
        int a[]= {5,10};
        try{
            int b= Integer.parseInt(args[0]);
            int x = a[b]/(b-a[1]);
            System.out.println("x="+x);
        }
        catch(ArithmeticException e)
        {
            System.out.println(e.toString());
        }
        catch(NumberFormatException e)
        {
            System.out.println(e.toString());
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println(e.toString());
        }
        System.out.println("Hello This is Exception Test");
    } // End of main() method
}// End of class Exceptiondemo

Finally Block

Can also use the optional finally block at the end of the try-catch block  

finally block provides a mechanism to clean up regardless of what happens within the try block. (Can be used to close files or to release other system resources)

The final block is always excuted. And the next statement will be excuted too.

 

Exceptions - Checked and Unchecked

Java allows for two types of exceptions:

Checked  

• If your code invokes a method which is defined to throw checked exception, your code MUST provide a catch handler
• The compiler generates an error if the appropriate catch handler is not present  
• Those other exceptions that the compiler can detect easily  
• Usually originate in library code.  For example, exceptions occurring during I/O, SMSLib, Files  
• Compiler ensures that: checked exceptions are:  caught using try-catch or  are specified to be passed up to calling method 

　　Handling Checked Exception

Every method must catch checked exceptions OR specify that it passes them to the caller (using the throws keyword)

void readFile(String filename) { 
    try {
        FileReader reader = new FileReader("myfile.txt");
        // read from file . . .
    } catch (FileNotFoundException e) {
        System.out.println("file was not found");
    }
}

// OR

void readFile(String filename) throws FileNotFoundException{
    FileReader reader = new FileReader("myfile.txt");
    // read from file . . .
}

Unchecked

• These exceptions can occur through normal operation of the virtual machine.  You can choose to catch them or not.
• If an unchecked exception is not caught, it will go to the default catch-all handler for the application
• All Unchecked exceptions are subclassed from RuntimeException  
• Unchecked exceptions or RuntimeExceptions occur within the Java runtime system    
• Examples of unchecked exceptions
  • arithmetic exceptions (dividing by zero)  
  • pointer exceptions (trying to access an object’s members through a null reference)  
  • indexing exceptions (trying to access an array element with an index that is too large or too small)      
• Can occur at many points in the program  
• Program handling such exceptions would be cluttered, pointlessly. (Only handle unchecked exceptions at important program points)

　　Common Unchecked Exceptions: 

　　NullPointerException

          int [] arr = null;
          arr[0] = 1;    // NullPointerException
          arr = new int [4];
          int i;
          for (i = 0; i <= 4; i++)
         {
            arr[i] = i;
            arr[i-1] = arr[i-1] / 0;
         }

　　ArrayIndexOutOfBoundsException

int [] arr = null;
arr[0] = 1;
arr = new int [4];
int i;
for (i = 0; i <= 4; i++)
{
  arr[i] = i;     // ArrayIndexOutOfBoundsException
  arr[i-1] = arr[i-1] / 0;
}

　　ArithmeticException

 int [] arr = null;
 arr[0] = 1;
 arr = new int [4];
 int i;
 for (i = 0; i <= 4; i++)
 {
   arr[i] = i;
   arr[i-1] = arr[i-1] / 0;   // ArithmeticException
 }

　　ArrayIndexOutOfBoundsException OR NumberFormatException

class Exceptiondemo2
{
public static void main(String args[])
{
double a= Double.parseDouble(args[0]); 
}
}
// args[0] can throw either ArrayIndexOutOfBoundsException or NumberFormationException

 

Write Own Exceptions

At lease 2 typre of execption constructors exist:

1. Default construct: No arguments

NullPointerException e = new NullPointerException();

2. Constructor that has a detailed message: Has a single String argument

IllegalArgumentExceptione e = new IllegalArgumentException(“Number must be positive");

 

// Your own exceptions must be a subclass of the Exception class and have at least the two standard constructors

public class MyCheckedException extends IOException{
    public MyCheckedException() {} 
    public MyCheckedException(String m){ super(m);}
}
 
public class MyUncheckedException extends RuntimeException {
    public MyUncheckedException() {} 
    public MyUncheckedException(String m){ super(m);}
}

If a user can reasonably be expected to recover from an exception, make it a checked exception  

If a user cannot do anything to recover from the exception, make it an unchecked exception 

Exception Class Hierarachy

 

Examples and Review

1.

package exceptions;

class ExceptionDemo1
{
    public static void main(String arhs[])
    {
        int a=10;
        int b= 5;
        int c =5;
        try
        {
            int x = a/(b-c);
            System.out.println("c="+c);
        }
        catch(ArithmeticException e)
        {
            System.out.println(e.toString());
        }
        int y = a/(b+c);
        System.out.println("y="+y);
    }
}
java.lang.ArithmeticException: / by zero 
y=1

2.

package exceptions;

class Nestedtry {
    public static void main(String args[]) {
        int a[] = {2,5,6};
        try {
            int b = Integer.parseInt(args[0]);
            try  {
                int c[] = {4,5,6};
                int d  = c[b]/(c[b]-4);
            } // End of inner try
            catch(ArrayIndexOutOfBoundsException e){
                System.out.println("Exception : "+ e.toString());
                System.out.println("By Inner try");
            }
            catch(ArithmeticException e){
                System.out.println("Exception : "+ e.toString());
                System.out.println("By Inner try");
            }
        } // End of outer try
        catch(ArrayIndexOutOfBoundsException e){
            System.out.println("Exception : "+e.toString());
            System.out.println("By Outr try");
        }
        catch(NumberFormatException e){
            System.out.println("Exception : "+ e.toString());
            System.out.println("By Outer try");
        }
    } // End of main
} // End of class

D:\java\bin>java nestedtry
Exception : java.lang.ArrayIndexOutOfBoundsException: 0
By Outer try

D:\java\bin>java nestedtry 4
Exception : java.lang.ArrayIndexOutOfBoundsException: 4
By Inner try

D:\java\bin>java nestedtry 0
Exception : java.lang.ArithmeticException: / by zero
By Inner try

3.