Components of exception handler are try, catch, and finally blocks, as shown in the figure that follows:

try {

} catch (ExceptionType name) {

} catch (ExceptionType name) {

} finally {

}

The first step in constructing an exception handler is to enclose the code that might throw an exception within a try block. You associate exception handlers with a try block by providing one or more catch blocks directly after the try block. No code can be between the end of the try block and the beginning of the first catch block.

Each catch block is an exception handler that handles the type of exception indicated by its argument. The argument type, ExceptionType, declares the type of exception that the handler can handle and must be the name of a class that inherits from the Throwable class. The handler can refer to the exception with name. The catch block contains code that is executed if and when the exception handler is invoked. The runtime system invokes the exception handler when the handler is the first one in the call stack whose ExceptionType matches the type of the exception thrown. The system considers it a match if the thrown object can legally be assigned to the exception handler's argument.

The finally block always executes when the try block exits. This ensures that the finally block is executed even if an unexpected exception occurs. However, finally is useful for more than just exception handling; it allows the programmer to avoid having cleanup code accidentally bypassed by a return, continue, or break. Putting cleanup code in a finally block is always a good practice, even when no exceptions are anticipated.

An example for exception handler components are as follows:

public class ExceptionHandlingExample {

  public static void main(String args[]){  
  try{ 
    //code that might throw an exception in try block
    System.out.println("Try block executing...");
    int i = 10/0;  
    System.out.println(i);  
  }
  catch(ArithmeticException e){
    //handles ArithmeticException
    System.out.println("Arithmetic Exception catch block executing...");
    System.out.println(e);
  } 
  catch(NullPointerException e){
    //handles NullPointerException
    System.out.println("Null Pointer Exception catch block executing...");
    System.out.println(e);
  }
  finally{
    System.out.println("finally block is always executed");
  }
   }
}

The output is as follows:

Try block executing...
Arithmetic Exception catch block executing...
java.lang.ArithmeticException: / by zero
finally block is always executed

The throw keyword is used to explicitly throw an exception. We can throw either checked or unchecked exceptions. The throw keyword is mainly used to throw a custom exception.

The following example performs division operation by passing two integer numbers as a parameter. If the denominator is zero, then throw ArithmeticException; otherwise, calculate the division operation:

public class ThrowExample {

  private int calculateDivision(int number1, int number2){
   if(number2 == 0){
  //throw exception
  throw new ArithmeticException("Division not possible, denominator should be greater than zero.");
  } else{
    //calculate division and return result
    return number1/number2;
    }
  }

  public static void main(String args[]){ 
    try {
    ThrowExample obj = new ThrowExample();
    //call calculateDivision method
    System.out.println(obj.calculateDivision(10, 0));
  } catch (Exception e) {
    //if any exception catch and print the message
    System.out.println(e.getMessage());
    }
  }
}

The output will be as follows:

Division not possible, denominator should be greater than zero.

Java IO is an API used for reading from a file and writing data to a file known as Java input and output operations. The File class in the Java IO API gives access to the underlying filesystem. Using the File class, you can perform the following operations:

The File class gives access to the file and file system metadata. To perform read and write operations on a file, you should use FileInputStream and FileOutputStream. FileInputStream and FileOutputStream classes are used to read and write data in a file.

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileIOStreamExample{
  public static void main(String args[]){
  try{  
    //FileOutputStream create file and connect write mode
    FileOutputStream fOut = new FileOutputStream("c:\\abc.txt");
    String str = "Working with Java FileInputStream and FileOutputStream class";

    //Contents of bytes and write to a file
    byte stringBytes[]=str.getBytes();
    fOut.write(stringBytes);

    //Close the file
    fOut.close();
    System.out.println("Written contents to file...");

    //FileinputStraem connect read mode
    FileInputStream fIn = new FileInputStream("c:\\abc.txt");
    int i;  
    while((i = fIn.read())!= -1){
    System.out.print((char)i);  
    }

    //Close the file
    fIn.close();  
    System.out.println();
    System.out.println("Read contents from file...");
  }catch(Exception e){
    System.out.println(e);
    }
  }
}

Written contents to file...
Working with Java FileInputStream and FileOutputStream class
Read contents from file...