Exception Handling in Java

An exception is defined as an abnormal condition that may happen at runtime and disturb the normal flow of the program.

An exception can occur for many different reasons. Following are some scenarios where an exception occurs.

• A user has entered an invalid data.
• A file that needs to be opened cannot be found.
• A network connection has been lost in the middle of communications or the JVM has run out of memory.

The Exception Handling in Java is a mechanism to handle the runtime errors so that the normal flow of the application can be maintained.

There are three categories of exceptions:

• Checked exceptions − a checked exception is an exception that is checked (notified) by the compiler at compilation-time; these are also called as compile time exceptions. These exceptions should be taken care of (handle) by programmers.

• Unchecked exceptions − an unchecked exception is an exception that occurs at the time of execution. These are also called as Runtime Exceptions. These include programming bugs, such as logic errors or improper use of an API. Runtime exceptions are ignored at the time of compilation.

• Errors − these are not exceptions at all, but problems that arise beyond the control of the user or the programmer. Errors are typically ignored in code because rarely anything can be done about an error. For example, if a stack overflow occurs, an error will arise. They are also ignored at the time of compilation.

 

Hierarchy of Java Exception classes

 

All exception classes are subtypes of the java.lang.Exception class. The exception class is a subclass of the Throwable class. Other than the exception class there is another subclass called Error which is derived from the Throwable class.

 

Java Exception Keywords

Java provides five keywords that are used to handle the exception – try, catch, finally, throw, throws.

 

The ‘try’ keyword is used to specify a block where an exception code is placed and this block must be followed by either catch or finally.

 

The "catch" block is used to handle the exception. It must be preceded by try block. It can be followed by finally block later.

 

try {

   // Protected code

} catch (ExceptionName e1) {

   // Catch block

}

 

Ex:

import java.io.*;

public class ExcTest {

   public static void main(String args[]) {

      try {

         int a[] = new int[2];

         System.out.println("Access third element:" + a[3]);

      }catch (ArrayIndexOutOfBoundsException e) {

         System.out.println("Exception thrown  :" + e);

      }

      System.out.println("Out of the try block");

   }

}

 

A try block can be followed by multiple catch blocks. The syntax for multiple catch blocks looks like the following −

 

Syntax:

try {

   // Protected code

} catch (ExceptionType1 e1) {

   // Catch block

} catch (ExceptionType2 e2) {

   // Catch block

} catch (ExceptionType3 e3) {

   // Catch block

}

 

The "throw" keyword is used to throw an exception.

Example:

public class ExceptionDemo {

            static void canVote(int age){

            if(age<18)

            try{

                throw new Exception();

            }catch(Exception e){

                System.out.println("you are not an adult!");

            }

            else

                           System.out.println("you can vote!");

            }

            public static void main (String[] args) {

                        canVote(20);

                        canVote(10);

            }

}

 

The "throws" keyword is used to declare exceptions. It specifies that an exception may occur in the method. It doesn't throw an exception. It is always used with method signature. Throws keyword is used when callee doesn’t want to handle the exception rather it wants to extend this responsibility of handling the exception to the caller of the function.

 

Ex:

public class ExceptionDemo {

            static void func(int a) throws Exception{

                           System.out.println(10/a); 

            }

            public static void main (String[] args) {

                        try{

                            func(10);

                            func(0);

                        }catch(Exception e){

                           System.out.println("can't divide by zero");

                        }

           

            }

}

 

The "finally" block is used to execute the necessary code of the program. It is executed whether an exception is handled or not. Using a finally block allows you to run any cleanup-type statements that you want to execute, no matter what happens in the protected code.

A finally block appears at the end of the catch blocks and has the following syntax –

 

try {

   // Protected code

} catch (ExceptionType1 e1) {

   // Catch block

} catch (ExceptionType2 e2) {

   // Catch block

} catch (ExceptionType3 e3) {

   // Catch block

}finally {

   // The finally block always executes.

}