Sunday, April 1, 2012

Exception


Exception
=======
Java exception handling is managed via five keywords.
try
catch
throw
throws
finally

The general form of an exception-handling block:
try
{
          //block of code to monitor for errors
}
catch(Exception Type1 exObj)
{
          //exception handler for ExceptionType1
}
catch(Exception Type2 exOb)
{
          //exception handler for Exception Type2
}
//......
finally
{
          //block of code to be executed before try block ends
}
Here, Exception Type is the type of exception that has occurred.
All exception types are subclasses of the built-in class Throwable.

Program1
-------------
class Ex
{  public static void main(String args[])
          {
                   int d=0;
                   int a=42/d;
                   System.out.println("a="+a);
          }
}

Program2
-------------
class Exc1{
          static void subroutine(){
                   int d=0;
                   int a=10/d;
          }
          public static void main(String args[]){
                   Exc1.subroutine();
          }
}

Program3
-------------

class Exc2{
          public static void main(String args[]){
                   int d,a;
                   try{
                             d=0;
                             a=42/d;
                             System.out.println("This is will not be printed");
                   }
                    catch(ArithmeticException e)
                   {
                             System.out.println("Division by zero");
                   }
                   System.out.println("After catch statement");
                   }
}

Demonstrate multiple catch statements.
--------------------------------------------------
class MultiCatch
{
          public static void main(String args[]){
                   try{
                             int a=args.length;
                             System.out.println("a="+a);
                             int b=42/a;
                             int c[]={1};
                             c[42]=99;
                   }catch(ArithmeticException e){
                             System.out.println("Divide by 0:"+e);
                   }
                   catch(ArrayIndexOutOfBoundsException e){
                             System.out.println("Array index oob:"+e);
                   }
                   System.out.println("After try/catch blocks.");
          }
}

//This program contains an error.
class SuperSubCatch{
          public static void main(String args[]){
                   try{
                             int a=0;
                             int b=42/a;
                   }catch(Exception e)
                   {
                             System.out.println("Generic Exception catch.");
                   }
                   /*This catch is never reached because Arithmetic Exception is a subclass of Exception*/
          /*       catch(ArithmeticException e){
                             System.out.println("This is never reached.");
                   }*/
          }
}

An example of nested try statement.
class NestTry{
          public static void main(String args[])
          {
                   try{
                             int a=args.length;
                             int b=42/a;
                             System.out.println("a="+a);
                             try{
                                      if(a==1)
                                      a=a/(a-a);
                                      if(a==2)
                                      {
                                      int c[]={1};
                                      c[42]=99;
                             }
                             }
                             catch(ArrayIndexOutOfBoundsException e){
                                      System.out.println("Array Index Out of Bounds:"+e);
                             }
                   }
                   catch(ArithmeticException e){
                             System.out.println("Divide by 0: "+e);
                   }
          }
}

Try statements can be implicitly nested via calls to methods.
class MathNestTry{
          static void nesttry(int a){
                   try{
          if(a==1)
          a=a/(a-a);
          if(a==2)
          {
                             int c[]={1};
                             c[42]=99;
                   }
          }
          catch(ArrayIndexOutOfBoundsException e){
                   System.out.println("Array Index Out of Bounds:"+e);
          }
}

          public static void main(String args[])
                   {
                             try{
                                      int a=args.length;
                                      int b=42/a;
                                      System.out.println("a="+a);
                                      nesttry(a);
                   }
                   catch(ArithmeticException e){
                                                System.out.println("Divide by 0: "+e);
                   }
          }
}

throw
--------
general form of throw is shown here:
throw ThrowableInstance;
Here, ThrowableInstance must be an object of type Throwable or a subclass of Throwable.

class ThrowDemo
{
          static void demoproc(){
                   try{
                             throw new NullPointerException("Demo");
                   }catch(NullPointerException e){
                             System.out.println("Caught inside demoproc.");
                             throw e;
                   }
          }
          public static void main(String args[]){
                   try{
                             demoproc();
                   }catch(NullPointerException e){
                             System.out.println("Recaught :"+e);
                   }
          }
}

Here, new is used to construct an instance of NullPointerException.  All of Java's built-in-run-time exceptions have two constructors: one with no prameter and one that takes a string parameter.  When the second form is used, the argument specifies a string that describes the exception.  This string is displyed when the object is used as an argument to print() or println().  It can also be obtained by a call to getMessage(), which is defined by Throwable.

throws
---------
The general form
type method-name(parameter-list)throws exception-list
{
          //body of method
}

class ThrowsDemo
{
          static void throwone()throws IllegalAccessException
          {
                   System.out.println("Inside throwOne.");
                   throw new IllegalAccessException("demo");
          }
          public static void main(String arg[])
          {
                   try{
                             throwone();
                   }catch(IllegalAccessException e){
                             System.out.println("Caught "+e);
                   }
          }
}

Finally
---------
class Final
{
          public static void main(String arg[])
          {
                   int a,d;
                   try
                   {
                             d=0;//d=10;
                             a=50/d;
                             System.out.println("Exception not occur");
                             System.out.println(a);
                   }
                   catch(Exception ae)
                   {
                             System.out.println("Don't use zero divisor");
                   }
                   finally{
                             System.out.println("U continue your work");
                   }
                   System.out.println("After try/catch statement");
          }
}



Java's Built-in Exceptions
---------------------------------
The most general of these exceptions are subclasses of the standard type RuntimeException.  Since java.lang is implicitly imported into all java programs, most exceptions derived from RuntimeException are automatically available.

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.
·        IllegalArgumentException                Illegal argument used to invoke
                                                                   a method
·        IndexOutOfBoundsException           some type of index is out-of-            
                                                                   bounds.
·        NegativeArraySizeException            Array created with a negative
                                                                   size.
·        NullPointerException                       Invalid use of a null reference.
·        NumberFormatException                           Invalid conversion of a string to
                                                                          a numeric format
·        SecurityException                                       Attempt to violate security

Creating Your Own Exception Subclasses
================================
This program creates a custom exception type.
class MyException extends Exception{
          int detail;
          MyException(int a){
                   detail=a;
          }
          public String toString(){
                   return "MyException["+detail+"]";
          }
}
class ExceptionDemo{
          static void compute(int a)throws MyException{
                   System.out.println("Called compute("+a+")");
                   if(a>10)
                   throw new MyException(a);
                   System.out.println("Normal exit");
          }
          public static void main(String args[])
          {
                   try{
                             compute(1);
                             compute(22);
                   }catch(Exception e){
                             System.out.println("Caught "+e);
                   }
          }
}


Method                                                            Description
getMessage                    Returns a string containing the error message.
toString                         Returns a string describing the exception object.

StackTraceelements              
Writes the exception object and its backtrace to standard error.A stack trace is a listing of all pending method calls at a particular point in the execution of the program.                               

No comments:

Post a Comment