Exception Handling

IADCS Diploma Course Exception Handling U Nyein Oo COO/Director(IT) Myanma Computer Co., Ltd

Introduction to Exception Is a special type of error It occurs at runtime in a code sequence Abnormal conditions that occur while executing the program cause exceptions If these conditions are not dealt with, then the execution can be terminated abruptly

Purpose of Exception handling Minimize the chances of a system crash, or abrupt program termination For example, In an I/O operation in a file. If the data type conversion is not properly done, an exception occurs, and the program aborts, without closing the file. This may damage the file, and the resources allocated to the file may not return to the system

Handling Exceptions When an exception occurs, an object that represents that exception is created This object is then passed to the method where the exception has occurred The object contains detailed information about the exception. This information can be retrieved and processed The ’throwable’ class that Java provides is the superclass of the Exception class, which is, in turn, the superclass of individual exceptions

Structure of Exception Object Error Throwable Exception (LinkageError, ThreadDeath, VirtualMachineError) ClassNotFoundException IOException(EOF,FileNotFound) NoSuchFieldException NoSuchMethodException RuntimeException (Arithemetic,IllegalArgument, IndexOutOfBounds,NullPointer)

Structure of Exception(Cont:) Object Throwable Error Exception Runtime Exception uncheck check uncheck

How exception work? //to show exception class UNO{ public static void main(String args[]){ int num=Integer.parseInt(args[0]); System.out.println("Here is "+num); } }

Exception handling Model Is also known as the ‘catch and throw’ model When an error occurs, an ‘exception’ is thrown, and caught in a block K eywords to handle exceptions try catch throw throws finally

Structure of the exception handling model Syntax try { …. } catch(Exception e1) { …. } catch(Exception e2) { …. } catch(Exception eN) { …. } finally { …. }

Advantages of ‘Catch and Throw’ Model The programmer has to deal with an error condition only where necessary. It need not be dealt with at every level An error message can be provided in the exception-handler

‘ try’ and ‘catch’ Blocks Is used to implement the ‘catch and throw’ model of exception handling A ‘try’ block consists of a set of executable statements A method, which may throw an exception, can also be included in the ‘try’ block One or more ‘catch’ blocks can follow a ‘try’ block These ‘catch’ blocks catch exceptions thrown in the ‘try’ block

try’ and ‘catch’ Blocks (Contd…) To catch any type of exception, specify the exception type as ‘Exception’ catch(Exception e) When the type of exception being thrown is not known, the class ‘Exception’ can be used to catch that exception The error passes through the ‘try catch’ block, until it encounters a ‘catch’ that matches it, or the program terminates

Example of catch and throw model //Number Format Exception Example class Try_Example{ public static void main(String args[]){ try{ int n=Integer.parseInt(args[0]); System.out.println("N is "+n); } catch(Exception e){ System.out.println("E is "+e); } } }

Example(cont) //Arithemetic Exception Example class Try_Example{ public static void main(String args[]){ int demo=0; try{ System.out.println(20/demo); } catch(Exception e){ System.out.println("E is "+e); } } }

Multiple Catch Blocks Multiple ‘catch()’ blocks process various exception types separately Example try { doFileProcessing(); displayResults(); } catch(LookupException e) { handleLookupException(e); } catch(Exception e) { System.err.println(“Error:”+e.printStackTrace()); }

Multiple Catch Blocks (Contd…) When nested ‘try’ blocks are used, the inner ‘try’ block is executed first Any exception thrown in the inner ‘try’ block is caught in the following ‘catch’ blocks If a matching ‘catch’ block is not found, then ‘catch’ blocks of the outer ‘try’ blocks are inspected Otherwise, the Java Runtime Environment handles the exception

‘finally’ Block Takes care of all the cleanup work when an exception occurs Can be used in conjunction with a ‘try’ block Contains statements that either return resources to the system, or print messages Closing a file Closing a result set (used in Database programming) Closing the connection established with the database

‘ finally’ Block (Contd…) Example try { doSomethingThatMightThrowAnException( ); } finally { cleanup( ); }

‘ finally’ Block (Contd…) Is optional Is placed after the last ‘catch’ block The ‘finally’ block is guaranteed to run, whether or not an exception occurs

Example of Finally Block //Finally Block Example class Finally_Example{ public static void main(String args[]){ int demo=0; try{ System.out.println(20/demo); } catch(Exception e){ System.out.println("E is "+e); } finally{ System.out.println("Finally Executed"); } } }

User-defined Exceptions with ‘throw’ and ‘throws’ statements Exceptions are thrown with the help of the ‘throw’ keyword The ‘throw’ keyword indicates that an exception has occurred The operand of throw is an object of a class, which is derived from the class ‘Throwable’ Example of the ‘throw’ statement try{ if (flag < 0) { throw new MyException( ) ; // user-defined } }

User-defined Exceptions with ‘throw’ and ‘throws’ statements (Contd…) A single method may throw more than one exception Example of the ‘throw’ keyword to handle multiple exceptions public class Example { public void exceptionExample( ) throws ExException, LookupException { try { // statements } catch(ExException exmp) { …. } catch(LookupException lkpex) { …. } } }

User-defined Exceptions with ‘throw’ and ‘throws’ statements (Contd…) The ‘Exception’ class implements the ‘Throwable’ interface, and provides some useful features for dealing with exceptions Advantage of subclassing the Exception class is that the new exception type can be caught separately from other Throwable types

User Defined Exception Example public class ExTest{ public static void main(String args[]){ int num=Integer.parseInt(args[0]); try{ if(num<0) throw new MyExceptionTest(); } catch(MyExceptionTest e) { System.out.println(e); } } } public class MyExceptionTest extends ArithmeticException{ MyExceptionTest(){ super("You have passed Illegal Operation"); } }

Multi catch example public class Pre { public static void main (String argv[]) { try { double d = Double.valueOf(argv[0]).doubleValue(); System.out.println (d); } catch (ArrayIndexOutOfBoundsException e) { System.out.println ("An argument is required."); return; } catch (NumberFormatException e) { System.out.println ("The argument must be a real number."); return; } } }

List of Exceptions RuntimeException ArithmeticException IllegalAccessException IllegalArgumentException ArrayIndexOutOfBoundsException NullPointerException SecurityException ClassNotFoundException NumberFormatException AWTException IOException FileNotFoundException EOFException NoSuchMethodException InterruptedException

Exception Handling

More Related Content

What's hot

Similar to Exception Handling

More from backdoor

Recently uploaded

Exception Handling