exception handling

Exception Handling in Java Types of Errors 1.Compile time All syntax errors identified by java compiler. No class file is created when this occurs. So it is necessary to fix all compile time errors for successful compilation. Egs: Missing of semicolon, use of = instead of ==

Exception Handling in Java 2.Run time Some pgms may not run successfully due to wrong logic or errors like stack overflow. Some of the Common run time errors are: Division by 0 Array index out of bounds Negative array size etc..

Exception Handling in Java Exception is a condition caused by a run time error in the program. When the java interpreter identifies an error such as division by 0 it creates an Exception object and throws it Definition: An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions. Is defined as a condition that interrupts the normal flow of operation within a program.

Exception Handling in Java Java allows Exception handling mechanism to handle various exceptional conditions. When an exceptional condition occurs, an exception is said to be thrown. For continuing the program execution, the user should try to catch the exception object thrown by the error condition and then display an appropriate message for taking corrective actions. This task is known as Exception handling

Exception Handling in Java This mechanism consists of : 1. Find the problem(Hit the Exception) 2. Inform that an error has occurred(Throw the Exception) 3. Receive the error Information(Catch the Exception) 4. Take corrective actions(Handle the Exception)

Exception Handling in Java In Java Exception handling is managed by 5 key words: try catch throw throws finally

Exception Handling in Java Throwable Exception error InterruptedException (checked exception) RuntimeException (unchecked exception) Exception Hierarchy Package java.lang

Exception Handling in Java Unchecked exception: These exception need not be included in an method’s throws list The compiler does not check to see if a method handles or throws these exception these are subclasses of RuntimeException The compiler doesn't force client programmers either to catch the exception or declare it in a throws clause. Class Error and its subclasses also are unchecked. Checked exception: Must be included in an method’s throws list if that method can generate one of those exceptions and does not handle it itself These exception defined by java.lang

Exception Handling in Java Java’s unchecked RuntimeException subclasses defined in java.lang Exception Meaning ArithmeticException Arithmetic error, such as divide-by-zero ArrayIndexOutOfBoundsException Array index is out-of-bounds ArrayStoreException Assignment to an array element of an incompatible type ClassCastException Invalid cast EnumConstantNotPresentException An attempt is made to use an undefined enumeration value IllegalArgumentException Illegal argument used to invoke a method IllegalMonitorStateException Illegal monitor operation, such as waiting on an unlocked thread IllegalStateException Environment or application is in incorrect state IllegalThreadStateException Requested operation not compatible with current thread state IndexOutOfBoundsException Some type of index is out-of-bounds NegativeArraySizeException Array created with a negative size

Exception Handling in Java Exception Meaning NullPointerException Invalid use of a null reference NumberFormatException Invalid conversion of a string to a numeric format SecurityException Attempt to violate security StringIndexOutOfBoundsException Attempt to index outside the bounds of a string TypeNotPresentException Type not fount UnsupportedOperationException An unsupported operation was encountered

Exception Handling in Java Java’s checked Exception defined in java.lang Exception Meaning ClassNotFoundException Class not found CloneNotSupportedException Attempt to clone an object that does not implement the Cloneable interface IllegalAccessException Access to a class is denied InstantiationException Attempt to create an object of an abstract class or interface InterruptedException One thread has been interrupted by another thread NoSuchFieldException A requested field does not exist NoSuchMethodException A requested method does not exist

Exception Handling in Java class Ex{ public static void main(String args[]){ int a=0; int b=2/a; } } Java.lang.ArithmeticException: / by zero at Ex.main

Exception Handling in Java try & catch try Block Statement that causes Exception Catch Block Statement that causes Exception

Exception Handling in Java try { Statement: } catch (Exception-type e){ statement; }

Exception Handling in Java class Ex{ public static void main(String args[]){ int d,a; try{ d=0; a=10/d; System.out.println("from try"); }catch(ArithmeticException e) { System.out.println("divsn by Zero"); } System.out.println("after catch"); } } Once an exception is thrown , program control transfers out of the try block into the catch block. Once the catch statement is executed pgm control continues with the next line following the entire try/catch mechanism.

Exception Handling in Java We can display the description of an Exception in a println statement by simply passing the exception as an argument. catch(ArithmeticException ae){ System.out.println(“Exception:”+ae); } o/p Exception:java.lang.ArithmeticException: /by zero

Common Throwable methods getMessage(); All throwable objects can have an associated error message. Calling this message will return the message if one present. getLocalizedMessage(); gets the localized version of error message. printStackTrace(); sends the stack trace to the system console. This is a list of method calls that led to the exception condition. It includes line number and file names too. Printing of the stack trace is the default behavior of a runtime exception when u don’t catch it ourselves. Exception Handling in Java

catch(ArithmeticException e){ System.out.println(e.getMessage()); //e.printStackTrace(); } o/p: E:\JAVAPGMS>java Ex / by zero catch(ArithmeticException e){ e.printStackTrace(); } E:\JAVAPGMS>java Ex o/p: java.lang.ArithmeticException: / by zero at Ex.main(Ex.java:9) Use of getMessage() and printStackTrace() Exception Handling in Java

Exception Handling in Java Multiple catch Statement some cases, more than one exception could be raised by a single piece of code. such cases we can specify two or more catch clauses, each catching a different type of exception. when an exception thrown, each catch statement is inspected in order, and the first one whose type matches that of the exception is executed. After 1 catch statement is executed, the others are bypassed and execution continues after the try/catch block.

Exception Handling in Java class Ex{ public static void main(String args[]){ int d,a,len; try{ len=args.length; a=10/len; int c[]={1}; c[10]=23; } catch(ArithmeticException e){ System.out.println("divsn by Zero"+e); } catch(ArrayIndexOutOfBoundsExcept ion ae){ System.out.println("Array index"+ae); } System.out.println("after catch"); } }

Exception Handling in Java In multiple catch statement exception subclasses must come before any of their superclasses. Because a catch statement that uses a superclass will catch exception of that type plus any of its subclasses. Thus a subclass would never be reached if it came after its superclass. Further java compiler produces an error unreachable code.

Exception Handling in Java Nested try statement try statement can be nested class Ex{ public static void main(String dd[]){ int d,a,len; try{ len=dd.length; a=10/len; System.out.println(a); try{ if(len==1) len=len/(len-len); if(len==2){ int c[]={1}; c[10]=23; } } catch(ArrayIndexOutOfBoundsExceptio n ae){ System.out.println("Array index"+ae); } } catch(ArithmeticException e){ e.printStackTrace(); } } System.out.println("after catch"); } }

E:\JAVAPGMS>java Ex java.lang.ArithmeticException: / by zero at Ex.main(Ex.java:9) after catch E:\JAVAPGMS>java Ex 20 10 java.lang.ArithmeticException: / by zero at Ex.main(Ex.java:14) after catch E:\JAVAPGMS>java Ex 20 30 5 Array indexjava.lang.ArrayIndexOutOfBoundsException: 10 after catch Exception Handling in Java

Exception Handling in Java throw It is possible to throw an exception explicitly. Syntax: throw ThrowableInstance throwableInstance must b an object of type Throwable or a subclass of Throwable. By two ways we can obtain a Throwable object 1. Using parameter into a catch clause 2. Creating one with new operator

Exception Handling in Java class throwDemo{ public static void main(String args[]){ int size; int arry[]=new int[3]; size=Integer.parseInt(args[0]); try{ if(size<=0)throw new NegativeArraySizeException("Illegal Array size"); for(int i=0;i<3;i++) arry[i]+=i+1; }catch(NegativeArraySizeException e){ System.out.println(e); throw e; //rethrow the exception } } }

E:\JAVAPGMS>java throwDemo -4 java.lang.NegativeArraySizeException: Illegal Array size Exception in thread "main" java.lang.NegativeArraySizeException: Illegal Array size at throwDemo.main(throwDemo.java:17) Exception Handling in Java

Exception Handling in Java throws If a method causing an exception that it doesn't handle, it must specify this behavior that callers of the method can protect themselves against the exception. This can be done by using throws clause. throws clause lists the types of exception that a method might throw. Form type methodname(parameter list) throws Exception list {//body of method}

Exception Handling in Java import java.io.*; class ThrowsDemo{ public static void main(String args[]) throws IOException,NumberFormatException{ int i; InputStreamReader is=new InputStreamReader(System.in); BufferedReader br=new BufferedReader(in); i=Integer.parseInt(br.readLine()); System.out.println (i); }}

Exception Handling in Java finally It creates a block of code that will be executed after try/catch block has completed and before the code following try/catch block. It will execute whether or not an exception is thrown finally is useful for: Closing a file Closing a result set Closing the connection established with database This block is optional but when included is placed after the last catch block of a try

Exception Handling in Java Form: try {} catch(exceptiontype e) {} finally {} finally finally Catch block try block

Exception Handling in Java Creating our own Exception class For creating an exception class our own simply make our class as subclass of the super class Exception. Eg: class MyException extends Exception { MyException (String msg){ super(msg); } }

Exception Handling in Java class TestMyException{ public static void main(String args[]){ int x=5,y=1000; try{ float z=(float)x/(float)y; if(z<0.01){ throw new MyException("too small number"); } }catch(MyException me){ System.out.println("caught my exception"); System.out.println(me.getMessage()); } finally{ System.out.println("from finally"); } } }

E:\JAVAPGMS>java TestMyException caught my exception too small number from finally O/P: Exception Handling in Java

exception handling

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to exception handling (20)

Recently uploaded (20)

exception handling