Java Exception Handling – A Complete Reference to Java Exceptions

Basically,  an Error is used by the Java run-time system (JVM) to indicate errors that are associated with the run-time environment (JRE). StackOverflowError is an example of such an error. Whereas Exception is used for exceptional conditions that user programs should catch. NullPointerException is an example of such an exception. 

Now that you know what errors and exceptions are, let’s find out the basic difference between them. Take a look at the below table which draws a clear line between both of them.

Now, we will dive deeper into exceptions and see how they can be handled. First, let’s see the different types of exceptions.

• Checked Exception
  It is an exception that occurs at compile time, also called compile time exceptions. If some code within a method throws a checked exception, then the method must either handle the exception or it must specify the exception using throws keyword.
• Unchecked Exception
  It is an exception that occurs at the time of execution. These are also called Runtime Exceptions. In C++, all exceptions are unchecked, so it is not forced by the compiler to either handle or specify the exception. It is up to the programmers to specify or catch the exceptions.

Basic Example of Exception

class Exception{
public static void main(String args[]){
try{
//code that may raise exception
}
catch(Exception e){
// rest of the program
  }
 }
}

Above code represent an exception wherein inside try block we are going to write a code that may raise an exception and then, that exception will be handled in the catch block.       

Types of Exceptions

1. Built-in Exceptions
   

   Built-in Exceptions	Description
   ArithmeticException	It is thrown when an exceptional condition has occurred in an arithmetic operation.
   ArrayIndexOutOfBoundsException	It is thrown to indicate that an array has been accessed with an illegal index. The index is either negative or greater than or equal to the size of the array.
   ClassNotFoundException	This exception is raised when we try to access a class whose definition is not found.
   FileNotFoundException	An exception that is raised when a file is not accessible or does not open.
   IOException	It is thrown when an input-output operation is failed or interrupted.
   InterruptedException	It is thrown when a thread is waiting, sleeping, or doing some processing, and it is interrupted.
   NoSuchFieldException	It is thrown when a class does not contain the field (or variable) specified.

2. User-Defined Exceptions
   

   Sometimes, the built-in exceptions in Java are not able to describe a certain situation. In such cases, a user can also create exceptions which are called ‘User-Defined Exceptions’.
   Key points to note:

   1. A user-defined exception must extend Exception class.
   2. The exception is thrown using throw keyword.

Example:

class MyException extends Exception{ 
 String str1;
 MyException(String str2) {str1=str2;}
  public String toString(){
   return ("MyException Occurred: "+str1);
 }
}
class Example1{
public static void main(String args[]){
 try{
      System.out.println("Start of try block");
      throw new MyException(“Error Message");
    }
    catch(MyException exp){System.out.println("Catch Block");
    System.out.println(exp);
 }
}

Now that you have seen the different types of exceptions, let’s dive deeper into this Java Exception Handling blog to understand various methods for handling these exceptions.

Exception Handling Methods

How to handle exceptions in Java?  

As I have already mentioned, handling an exception is very important, else it leads to system failure. But how do you handle these exceptions?

Java provides various methods to handle the Exceptions like:

• try
• catch
• finally
• throw
• throws

Let’s understand each of these methods in detail.