Exception Handling

 

Exception in Java

    Exception are such anomalous conditions (or typically an event) which changes the normal flow of execution of a program. Exceptions are used for signaling erroneous (exceptional) conditions which occur during the run time processing. Exceptions may occur in any programming language.

    Occurrence of any kind of exception in java applications may result in an abrupt termination of the JVM or simply the JVM crashes which leaves the user unaware of the causes of such anomalous conditions. However Java provides mechanisms to handle such situations through its superb exception handling mechanism. The Java programming language uses Exception classes to handle such erroneous conditions and exceptional events.

Exception Object

In java, when any kind of abnormal conditions occurs with in a method then the exceptions are thrown in form of Exception Object i.e. the normal program control flow is stopped and an exception object is created to handle that exceptional condition. The method creates an object and hands it over to the runtime system. Basically, all the information about the error or any unusual condition is stored in this type of object in the form of a stack. This object created is called an exception object the process is termed as throwing an exception. The mechanism of handling an exception is called catching an exception or handling an Exception or simply Exception handling. 

      As we have known that after throwing an exception it is handed off  to the runtime system that finds a possible method from an ordered list of methods to handle it.  The list of this type of methods is known as the call stack

      As we have already learned that, what are the exceptions. Point to be remember here is that exceptions are not errors rather they are some abnormal conditions that aren't necessarily errors. Therefore, the process of detecting the exceptions and responding to them as well is known as Exception handling. 

Following are the advantages of Exception-handling in Java:

• Exception provides the means to separate the details of what to do when something out of the ordinary happens from the main logic of a program. 
• One of the significance of this mechanism is that it throws an exception whenever a calling method encounters an error providing that the calling method takes care of that error.
• With the help of this mechanism the working code and the error-handling code can be disintegrated. It also gives us the scope of organizing and differentiating between different error types using a separate block of codes. This is done with the help of try-catch blocks. 
• Furthermore the errors can be propagated up the method call stack i.e. problems occurring at the lower level in the chain can be handled by the methods higher up the call chain .              
  
  
  

  Sample Code:-

  
  The basic syntax to handle an Exception looks like this:
  
                                                                                                                                                           String myException()
  {
  try
  {
  return myMethod();
  }
  catch ( IOException e )
  {
  return null;
  }
  }
   There are three types of Exceptions:
  
  There are three types of Exceptions:-
      
      These are the exceptions which occur during the compile time of the program. The compiler checks at the compile time that whether the program contains handlers for checked exceptions or not. These exceptions do not extend RuntimeException class and must be handled to avoid a compile-time error by the programmer. These exceptions extend the java.lang.Exception class  These exceptional conditions should be anticipated and recovered by an application. Furthermore Checked exceptions are required to be caught. Remember that all the exceptions are checked exceptions unless and until those indicated by Error, RuntimeException or their subclasses.         For example if you call the readLine() method on a BufferedReader object then the IOException may occur or if you want to build a program that could read a file with a specific name then you would be prompted to input a file name by the application. Then it passes the name to the  constructor for java.io.FileReader and opens the file. However if you do not provide the name of any existing file then the constructor throws java.io.FileNotFoundException which abrupt the application to succeed. Hence this exception will be caught by a  well-written application and will also prompt to correct the file name.
  Here is the list of checked exceptions.
  1. NoSuchFieldException  2. InstantiationException
  3. IllegalAccessException
  4.ClassNotFoundException
  5. NoSuchMethodException
  6. CloneNotSupportedException
  7. InterruptedException
  
  
  Unchecked Exceptions -
  
  
        Unchecked exceptions are the exceptions which occur during the runtime of the program. Unchecked exceptions are internal to the application and extend the java.lang.RuntimeException that is inherited from java.lang.Exception class. These exceptions cannot be anticipated and recovered like programming bugs, such as logic errors or improper use of an API. These type of exceptions are also called Runtime exceptions that are usually caused by data errors, like arithmetic overflow, divide by zero etc.
  
      Lets take the same file name example as described earlier. In that example the file name is passed to the constructor for FileReader. However, the constructor will throw NullPointerException if a logic error causes a null to be passed to the constructor. Well in this case the exception could be caught by the application but it would rather try to eliminate the bug due to which the exception has occurred. You must have encountered the most common exception in your program i.e. the ArithmeticException. I am sure you must be familiar with the reason of its occurrence that is when something tries to divide by zero. Similarly when an instance data member or method of a reference variable is to be accessed that hasn't yet referenced an object throws NullPointerException.
  
  Here is the list of unchecked exceptions.
  
  1. IndexOutOfBoundsException 
  2. ArrayIndexOutOfBoundsException
  3. ClassCastException
  4. ArithmeticException
  5. NullPointerException
  6. IllegalStateException
  7. SecurityException
  
  
  
  Error - 
  
       The errors in java are external to the application. These are the exceptional conditions that could not be usually anticipated by the application and also could not be recovered from. Error exceptions belong to Error and its subclasses  are not subject to the catch or Specify requirement. Suppose a file is successfully opened by an application for input but due to some system malfunction could not be able to read that file then the java.io.IOError would be thrown. This error will cause the program to terminate but if an application wants then the error might be caught. An Error indicates serious problems that a reasonable application should not try to catch. Most such errors are abnormal conditions.  
  
  NOTE-
   Hence we conclude that Errors and runtime exceptions are together called as unchecked exceptions. 
  
  
  
  
  
  

  Exception Classes:-

   

  "The hierarchy of exception classes commence from Throwable class which is the base class in java.lang. This class can be instantiated and thrown by the program."

  
  

  The hierarchy of exception classes commence from Throwable class which is the base class for an entire family of exception classes, declared in  java.lang package as java.lang.Throwable. A throwable contains a snapshot of the execution stack at the time it was created and also a message string that gives more information about the error. This class can be instantiated and thrown by the program. The throwable class is further divided into two subclasses :-
  
  
  

  1. Exceptions - Exceptions are thrown if any kind of unusual condition occurs that can be caught. Sometimes it also happens that the exception could not be caught and the program may get terminated. Remember that they are a member of Exception family and can be type of Checked or Unchecked exception.
  2.  Errors - When any kind of serious problem occurs which could not be handled easily like OutOfMemoryError then an error is thrown. Well, errors are not something which is thrown by you rather they are thrown by the Java API or by the Java virtual machine itself i.e. only the exceptions are thrown by your code and not the errors. Also Remember that they are a member of Error family.

  
  
  
  The exception classes can be explained as well seeing the exception hierarchy structure:
  
  
  
  
  
  
  The java.lang package defines several classes and exceptions. Some of these classes are not checked while some other classes are checked.
  
  

  EXCEPTIONS	DESCRIPTION	CHECKED	UNCHECKED
  ArithmeticException	Arithmetic errors such as a divide by zero	-	YES
  ArrayIndexOutOfBoundsException	Arrays index is not within array.length	-	YES
  ClassNotFoundException	Related Class not found	YES	-
  IOException	InputOuput field not found	YES	-
  IllegalArgumentException	Illegal argument when calling a method	-	YES
  InterruptedException	One thread has been interrupted by another thread	YES	-
  NoSuchMethodException	Nonexistent method	YES	-
  NullPointerException	Invalid use of null reference	-	YES
  NumberFormatException	Invalid string for conversion to number	-	YES

  As you have come to know that exceptions are Objects that means an object is thrown when you throw an exception. Moreover only those objects could be thrown whose classes are derived from Throwable. 

  It is interesting to note here that the objects of your own design could also be thrown provided that they should be the subclass of some member of the Throwable family. Also the throwable classes which are defined by you must extend Exception class. 

  It depends upon the situation that whether to use an existing exception class from java.lang or create any of your own. Such as IllegalArgumentException, a subclass of RuntimeException in java.lang can be thrown if any method with an invalid argument is thrown by you. On the other hand you need not to worry if you wish to impart some more information about any unusual condition other than a class from java.lang because it will be indicated by the class of exception object itself.  

  
  

  
  

  For example, if a thrown exception object has class IllegalArgumentException, that indicates someone passed an illegal argument to a method. Sometimes you will want to indicate that a method encountered an abnormal condition that isn't represented by a class in the Throwable family of java.lang.
  For instance, lets tweak an example below that demonstrates the exceptional conditions that might occur while driving a car.

  
  

  
  

  // In Source Packet in file except/ex1/SpeedException.java class SpeedException extends Exception { } // In Source Packet in file except/ex1/VeryFastException.java class VeryFastException extends SpeedException { } // In Source Packet in file except/ex1/VerySlowException.java class VerySlowException extends SpeedException { }

  
  

  Lets tweak the diagram below.

  
  

  It is clear from the above program that there is something abnormal with the speed of the car i.e. either it is very fast or it is very slow. Hence two exceptions are thrown by the program - VeryFastException and VerySlowException. To be more precise the SpeedException family specifies three new exceptions thrown by the program which indicate some abnormal conditions. That is the SpeedException specifies that there is something unusual with the speed; VeryFastException and VerySlowException specifies the abnormal conditions of the speed.
  
  NOTE: The SpeedException extends Exception only and not the Throwable or Error class.
  
  
  
  
  

  Java Catching and Handling Exceptions:-

   

  "The three exception handler components are used to catch and handle the exceptions. These are try, catch and finally clause."

   

  The various keywords for handling exceptions are below.

  • try
  • catch
  • finally
  • throw
  • throws

  
          The three exception handler components are used to catch and handle the exceptions. These are try, catch and finally clause. The mechanism to catch an exception in Java is to use try and catch block. Every catch block can handle only one type of exception however you can use more than one catch clause in a single try block. Simply a statement is surrounded by the try block that may cause the exception to occur. Then the try block is followed by the catch block. And if the exception occurs then this catch block specifies a code that should be executed.
  
  Using try and catch:-
  
  The syntax for the usage of try, catch and finally block is given below.
  
  try{
         ???
         ???
  }
  catch(<exceptionclass1> <obj1>){
         ???
         ???
  }
  finally{
         ???
         ???
  } 
  
  
  For using an exception handler in an application, the first step we need to do is to enclose the code that is likely to generate an exception inside a try block. If an exception occurs in the try block then it is handled by the exception handler associated with it. For doing this we need to have one or more catch blocks after the try block, where each catch block acts as an exception handler and can handle the type of exception indicated by its arguments.
  

  
  

  Lets have a look at the example which shows the implementation of the try, catch and finally block. Here we have used "fis = new FileInputStream (new File (args[0]));" which throws an exception if we write a name of a file which doesn't exist as shown in the output.

  
  

  import java.io.*; class Test{ public static void main(String args[])throws IOException { FileInputStream fis=null; try{ fis = new FileInputStream (new File (args[0])); } catch (FileNotFoundException e){ System.out.println("File not found!"); } finally{ fis.close(); } } }

  Output of program:
  File not found!
  
  

  
  

  
  

  Using final:- 

  
  

       It is always a good practice to use finally clause after the try and catch block because the finally block always executes even if an unexpected exception occurs i.e. whether or not an exception thrown. The finally block executes if and only if the try block exits. Other than exception handling the finally clause helps you in avoiding any cleanup code accidentally bypassed by a return etc. The statements within the finally block gets executed by the the runtime system  without taking care of what happens within the try block.  

  There are two steps to use the finally clause:

  • First, you need to enclose the code in a try block that has multiple exit points.
  • Secondly after the try block exits place the code that must be executed in a finally clause. 

  Same way we have used the finally block which will execute after the try and catch block.
  

  
  

  import java.io.*; class Test{ public static void main(String args[]){ FileInputStream fis=null; try { fis = new FileInputStream (new File (args[0])); int ch; while ((ch = fis.read()) != -1){ System.out.print ((char) ch); } } catch (FileNotFoundException e){ System.out.println("File not found!"); } catch (IOException e){ System.out.println("Unable to read file!"); } finally{ System.out.println(); System.out.println("In finally."); try{ if(fis!=null){ fis.close(); } } catch (IOException ioe){ System.out.println("In finally."); } } } }

   Output of program:

  File not found!
  
  In finally 

   

   

  Using throws:-  

  
  

        The other way to handle an exception is using the throws clause. When you call a method from the java API that throws a checked exception, you must either throw the exception or catch it. If you decide that you can't handle the exception properly, then the exception can be declared to the method header using the throws keyword  followed by the class name of the exception. 

  You might have come across the throws IOException clause in the method header. For example System.in.read() will give a compile error for IOException. Add the throws clause to the surrounding method to pass the error up to the next level (or else write your own catch/try handler). This clause is placed between the parameter list and the starting of the opening brace of the method. We use this clause when we know that a particular exception may occur. Then instead of terminating the program the compiler throws the exception.

  While the throw keyword (note the singular form) is used to force an exception. It can also pass a custom message to your exception handling module. for example:-

  throw new FileNotFoundException("Could not find books.txt");

  The syntax for coding the throws clause of a method is as:-

  method declaration throws Exception1,[Exception2] .......{ }

  Likewise we have used throws clause to the method header as "throws FileNotFoundException,IOException " which throws an exception as shown in the output.
  
  
  

  import java.io.*; class Test3{ public static void main(String args[]) throws FileNotFoundException,IOException { FileInputStream fis=null; fis = new FileInputStream (new File (args[0])); int ch; while ((ch = fis.read()) != -1){ System.out.print ((char) ch); } fis.close(); } }

  
  

   

  OUTPUT OF THE PROGRAM:-

   Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
  at Test3.main(Test3.java:6)

   

  How to Throw Exceptions in Java:-

   

    "Before catching an exception it is must to be thrown first. This means that there should be a code somewhere in the program that could catch the exception."

  Before catching an exception it is must to be thrown first. This means that there should be a code somewhere in the program that could catch the exception. We use throw statement to throw an exception or simply use the throw keyword with an object reference to throw an exception. A single argument is required by the throw statement i.e. a throwable object. As mentioned earlier Throwable objects are instances of any subclass of the Throwable class.
  throw new VeryFastException();
  Note: The reference should be of type Throwable or one of its subclasses.
  For instance the example below shows how to throw an exception. Here we are trying to divide a number by zero so we have thrown an exception here as "throw new MyException("can't be divided by zero");"
  

  class MyException extends Exception { public MyException(String msg){ super(msg); } } public class Test { static int  divide(int first,int second) throws MyException{   if(second==0)   throw new MyException("can't be divided by zero"); return first/second;  }  public static void main(String[] args) {   try { System.out.println(divide(4,0));   } catch (MyException exc) { exc.printStackTrace();   }   } }

  Output of program:
  

   MyException: can't be divided by zero
  at Test.divide(Test.java:10)
  at Test.main(Test.java:15)

   

  Difference between throw and throws keywords:-
  Whenever we want to force an exception then we use throw keyword. the throw keyword (note the singular form) is used to force an exception. It can also pass a custom message to your exception handling module. Moreover throw keyword can also be used to pass a custom message to the exception handling module i.e. the message which we want to be printed. For instance in the above example we have used -
  throw new MyException ("can't be divided by zero");
  Whereas when we know that a particular exception may be thrown or to pass a possible exception then we use throws keyword. Point to note here is that the Java compiler very well knows about the exceptions thrown by some methods so it insists us to handle them. We can also use throws clause on the surrounding method instead of try and catch exception handler. For instance in the above given program we have used the following clause which will pass the error up to the next level -
  static int  divide(int first,int second) throws MyException{
  
  
  
  
  Handling Multiple Catch Clauses:-
  
  
     So far we have seen how to use a single catch block, now we will see how to use more than one catch blocks in a single try block.In java when we handle the exceptions then we can have multiple catch blocks for a particular try block to handle many different kind of exceptions that may be generated while running the program i.e. you can use more than one catch clause in a single try block however every catch block can handle only one type of exception. this mechanism is necessary when the try block has statement that raise  different type of exceptions.
  The syntax for using this clause is given below:-
  

  try{ ??? ??? } catch(<exceptionclass_1> <obj1>){ //statements to handle the exception  } catch(<exceptionclass_2> <obj2>){ //statements to handle the exception  } catch(<exceptionclass_N> <objN>){ //statements to handle the exception  }

  When an exception is thrown, normal execution is suspended. The runtime system proceeds to find a matching catch block that can handle the exception. If no handler is found, then the exception is dealt with by the default exception handler at the top level.

  
  

  Lets see an example given below which shows the implementation of multiple catch blocks for a single try block.

  public class Multi_Catch {    public static void main (String args[])    {   int array[]={20,10,30};   int num1=15,num2=0;   int res=0;   try   {    res = num1/num2;   System.out.println("The result is" +res);   for(int ct =2;ct >=0; ct--)   {    System.out.println("The value of array are" +array[ct]);    }   }   catch (ArrayIndexOutOfBoundsException e)    {    System.out.println("Error?. Array is out of Bounds");   }    catch (ArithmeticException e)    {    System.out.println ("Can't be divided by Zero");    }   }   }

  Output of the program:

  Can't be divided by Zero

  
  

  
  

  
  

  
  

  
  

  
  

  Lets have an another output, in which the second catch block is skipped and the first catch block handles the error.
  
  

  public class Multi_Catch1 {    public static void main (String args[])    {   int array[]=new int [5];   int num1=15,num2=2;   int res=0;   try   {    res = num1/num2;   System.out.println("The result is" +res);   for(int ct =0;ct <=5; ct++)   {    array[ct] = ct * ct ;    }   }   catch (ArrayIndexOutOfBoundsException e)    {    System.out.println("Assigning the array beyond the upper bound");   }    catch (ArithmeticException e)    {    System.out.println ("Can't be divided by Zero");    }   }   }

  Output of the program:

  
  

  Assigning the array beyond the upper bound

  
  

  
  

  
  

  
  

  
  

  
  

  Handling the Unreachable Code Problem :-

  
  

      The multiple catch blocks can generate unreachable code error i.e. if the first catch block contains the Exception class object then the subsequent catch blocks are never executed.  This is known as Unreachable code problem. To avoid this, the last catch block in multiple catch blocks must contain the generic class object that is called the Exception class. This exception class being the super class of all the exception classes and is capable of  catching any  types of exception. The generic Exception class can also be used with multiple catch blocks.

  Take a look at the following example:

  public class Generic_Excep {    public static void main (String args[])   {    String str = "Exception" ;    int len=0;    try   {    StringBuffer sbuf = new StringBuffer(str);   len = str.length() ;    for(int ct=len;ct>=0;ct--)   {   System.out.print(sbuf.charAt(ct));    }    }    catch(Exception e)   {   System.out.println("Error...."+e);    }    }    }

  Output of the program:

  
  

  Error....java.lang.StringIndexOutOfBoundsException: String index out of range: 9

  
  

  
  

  
  

  
  

  
  

  
  

  Nested Try-Catch Blocks:-

   

      In Java we can have nested try and catch blocks. It means that, a try statement can be inside the block of another try. If an inner try statement does not have a matching catch statement for a particular exception, the control  is transferred to  the next try statement?s catch handlers that are expected for a matching catch statement. This continues until one of the catch statements succeeds, or until all of the nested try statements are done in.  If no one catch statements match, then the Java run-time system will handle the exception.
  The syntax of nested try-catch blocks is given below:
  
  
  

  try {   try {   // ...   }    catch (Exception1 e)    {    //statements to handle the exception   }    }    catch (Exception 2 e2)   {    //statements to handle the exception   }

  Lets have an example that uses the nested try-catch blocks
  
  
  
  
  

  import java.io.*; public class NestedTry{   public static void main (String args[])throws IOException  {   int num=2,res=0;      try{   FileInputStream fis=null;   fis = new FileInputStream (new File (args[0]));   try{   res=num/0;   System.out.println("The result is"+res);   }   catch(ArithmeticException e){   System.out.println("divided by Zero");   }   }   catch (FileNotFoundException e){   System.out.println("File not found!");   }   catch(ArrayIndexOutOfBoundsException e){   System.out.println("Array index is Out of bound! Argument required");   }   catch(Exception e){   System.out.println("Error.."+e);   } } }

  
  

   

  
  

  
  

  
  

  Catching Normal Exceptions:-

   

     The exceptions that are generated by methods are referred to as normal exceptions.  We have already learned that to catch an exception we use try and catch block.
  
  

  try { myTestException(); } catch(ExceptionType1 e) { System.out.println(e.getMessage()); } catch(Exceptiontype2 e) { System.out.println(e.getMessage()); }

  
  
     The code above shows how to handle multiple exceptions. We have used myTestException(); method here which generates two different types of exceptions handled by separate catch clauses in a unique manner. By comparing the exception type, the catch clauses are examined whenever an exception occurs in a try block A match will occur whenever the type of exception is same as that in catch clause or same as the subclass in the catch clause. Hence due to this multilevel catch handlers can be provided which are based on more derived exception types. Lets see one more example:
  
  
  

  FileInputStream fis=null; try{ fis = new FileInputStream (new File (args[0])); } catch (FileNotFoundException e){ System.out.println("File not found!"); + e.getMessage()); }

  
  
      Here we have created a file input stream and the constructor which takes a file name to read from will throw FileNotFoundException if the file couldn't be found. Within a try block an object is created that handles the exception FileNotFoundException in a catch block as the constructor is capable of throwing this exception.
  Catching Runtime Exceptions
  The exceptions which are not easily traced are known as Runtime Exceptions. For instance,
  
  
  

  try { int x = 50; for (int i = 15; i >= 0; i--) System.out.println(x / i); } catch(ArithmeticException e) { System.out.println(e.getMessage()); }

  
  
       The above code displays a for loop trying to divide a number by zero in its last iteration which would result in runtime exception. We have used try block to handle this exception and a corresponding handler by means of a catch clause. And if we won't handle the exception the program will end up with the termination. 
  The disadvantage in handling the runtime exception is that we need to put the doubtful code inside a try block. This approach sometimes causes a mess so its always better to avoid the problems which land you up with the troubles.
  

   

  
  

  
  
  

  Making Custom (User Define Exceptions):-

      So far you would have been known, how to be handled the exceptions in java =======
  So far you would have been known, how to be handled the exceptions in java >>>>>>> 1.3 that are thrown by the Java API but sometimes you may occasionally need to throw your own exception i.e. if you encounter a situation where none of those exception describe  your exception accurately or if you can't find the appropriate exception in the Java API, you can code a class that defines an exception that is more appropriate and that mechanism of handling exception is called Custom or User Defined Exception.
  In Java API all exception classes have two type of constructor. First is called default constructor  that doesn't accept any arguments. Another constructor accepts a string argument that provides the additional information about the exception. So in that way  the Custom exception behaves like the rest of the exception classes in Java API.
  There are two primary use cases for a custom exception.
  

  •  your code can simply throw the custom exception when something goes wrong. 
  • You can wrap an exception that  provides extra information by adding your own message.

  
  
  The code of a Custom exception:
  
  
  

  public  class ExceptionClassName extends Exception {    public ExceptionClassName(){ }   public ExceptionClassName(StringMessage)   {    super(message);    }  }

  
  

  Lets see an example that has the implementation of User Define Exception:

  
  

  import java.io.*; import java.util.*; class MyException extends Exception {    private String nm="";   public String getMessage(String s)    {    nm=s;    return ("you are not permitted to enter inside "+nm);    } } public class ExcepDemo   {   public static void main(String args[])throws MyException,IOException   {   String temp="";   try    {    String str="amit";    System.out.println("Enter the your name");   BufferedReader br=new BufferedReader(new InputStreamReader(System.in));   temp=br.readLine();    if(!temp.equals(str))   throw new MyException();   else    System.out.println("Welcome to Rose India");    }    catch(MyException e)    {   System.err.println(e.getMessage(temp));    }   catch(Exception e){   System.err.println(e);   }    }   }