Java Exceptions Cheat Sheet – Level Up Your Java Knowledge

In Java, an exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.

Types of Exceptions:

• Checked Exception:
  It is an exception that occurs at the compile time, also called compile time exceptions.

• Unchecked Exception:
  It is an exception that that occurs at the time of execution. These are also called Runtime Exceptions.

public class JavaExceptionExample{
  public static void main(String args[]){
    try{
         int data=100/0;
       }catch(ArithmeticException e){System.out.println(e);}
        System.out.println("rest of the code...");
     }
}

public String getMessage()

// Returns a detailed message about the exception

public String toString()

// Returns the name of the concatenated class with the result of getMessage()

public void printStackTrace()

// Prints the result of toString() along with the stack trace

public stackTraceElement [] getStackTrace()

// Returns an array containing each element on the Stack Trace

public Throwable fillInStackTrace()

// Fills the stack trace by adding previous information present in the stack.

Java try block is used to enclose the code that might throw an exception. 

try{  
//code that may throw exception
}catch(Exception_class_Name ref){}

Java catch block is used to handle the Exception. It must be used after the try block only.

public class Testtrycatch1{  
  public static void main(String args[]){  
    int data=50/0;//may throw exception  
    System.out.println("rest of the code..."); 
  }
}

The try block within a try block is known as nested try block in java.

class Exception{
  public static void main(String args[]){ 
    try{
      try{
          System.out.println("going to divide"); 
          int b=59/0;
         }catch(ArithmeticException e){System.out.println(e);}
      try{
          int a[]=new int[5];
          a[5]=4;
         }
        catch(ArrayIndexOutOfBoundsException e) {System.out.println(e);}  System.out.println("other statement);
        }catch(Exception e)
         {System.out.println("Exception handeled");} 
       System.out.println("casual flow");
    }
}

If you have to perform various tasks at the occurrence of various exceptions, you can use java multi-catch block.

public class SampleMultipleCatchBlock{ 
 public static void main(String args[]){ 
   try{
       int a[]=new int[5];  
       a[5]=30/0;
      }
      catch(ArithmeticException e)
        {System.out.println("task1  is completed");}
      catch(ArrayIndexOutOfBoundsException e)
        {System.out.println("task 2 completed");} 
      catch(Exception e)
        {System.out.println("task 3 completed");}  
      System.out.println("remaining code");
  }
}

//Java throw example
void a()
{
  throw new ArithmeticException("Incorrect");
}

//Java throws example
void a()throws ArithmeticException
{
  //method code
}

//Java throw and throws example
void a()throws ArithmeticException
{
  throw new ArithmeticException("Incorrect");
}

finally block is a block that is used to execute important code such as closing connection, stream etc. It is always executed whether an exception is handled or not.

class SampleFinallyBlock{
 public static void main(String args[]){ 
   try{
     int data=55/5;        
     System.out.println(data);
    }
    catch(NullPointerException e)
       {System.out.println(e);}  
    finally {System.out.println("finally block is executed");}  
    System.out.println("remaining code");
  }
}

finally example where exception occurs and handled

class SampleFinallyBlock{
  public static void main(String args[]){ 
    try{
        int data=25/0;        
        System.out.println(data);
       }
       catch(NullPointerException e)
         {System.out.println(e);}  
       finally {System.out.println("finally block is executed");}  
         System.out.println("remaining code");
  }
}

import java.io.*; 

class Parent{
void msg()
 {System.out.println("parent");}
}
class ExceptionChild extends Parent{ 
 void msg()throws IOException{
 System.out.println("ExceptionChild");
}
public static void main(String args[]){ 
   Parent p=new ExceptionChild(); 
   p.msg();
 }
}

import java.io.*;  

class Parent{
void msg()throwsArithmeticException
{System.out.println("parent");}
}
class ExceptionChild2 extends Parent{
 void msg()throws Exception {System.out.println("child");} 
 public static void main(String args[]){
 Parent p=new ExceptionChild2(); 
 try{
     p.msg();
    }catch(Exception e){}
}