throw Keyword in Java

In Java, throw keyword is used to explicitly throw an exception (a user-defined or built-in exception) to the JVM. An exception is an object that represents an error or unexpected condition in a program. When an exception is thrown, the program's normal flow of execution is interrupted, and the exception is handled.

We can throw either checked or unchecked exceptions in Java by using the throw keyword.

When an exception is explicitly thrown, the program execution flow transfers from the try block to the catch block.

The throw keyword is used inside the method, and it is mainly used to throw custom (user-defined) exceptions. Using the throw keyword, only one exception-type object can be thrown at a time.

  
  throw new exception_class_name ("error message");
  or
  exception_class_name expObject = new exception_class_name();
  throw expObject;

  
  throw new RecordNotFoundException ("error message");
  or
  RecordNotFoundException expObject = new RecordNotFoundException();
  throw expObject;

In the above example, we are throwing RecordNotFoundException explicitly; please note that when we are throwing custom exceptions, we make sure they are of type Throwable or a subclass of Throwable. For example, Exception is a subclass of Throwable, and the user-defined exceptions usually extend the Exception class.

As mentioned above, we can throw either checked or unchecked exceptions in Java by using the throw keyword. Let's understand this using the given examples below.

  
  import java.io.BufferedReader;
  import java.io.FileNotFoundException;
  import java.io.FileReader;
  public class ThrowWithCheckedException {
    public static void ReadStudentRecord() throws FileNotFoundException {
      FileReader file = new FileReader("studentRecord.txt");
      BufferedReader bf = new BufferedReader(file);
      // Explicitly throwing exception
      throw new FileNotFoundException();
    }
    
    public static void main(String args[]) {
      try {
        ReadStudentRecord();
      } catch (FileNotFoundException e) {
        e.printStackTrace();
      }
      System.out.println("Thank you...");
    }
  }

java.io.FileNotFoundException at com.javabytechie.throwkeyword.ThrowWithCheckedException.ReadStudentRecord(ThrowWithCheckedException.java:12) at com.javabytechie.throwkeyword.ThrowWithCheckedException.main(ThrowWithCheckedException.java:17)
Thank you...

  public class ThrowWithUncheckedException {
    public static void validateRollNumber(int rollNumber) {
      if (rollNumber < 1) {
        // throwing Arithmetic exception if roll number is not valid
        throw new ArithmeticException("ERROR: Invalid Roll Number");
      } else {
        System.out.println("Roll Number is valid.");
      }
    }
  
    public static void main(String args[]) {
      // calling method for checking roll number is valid or invalid
      validateRollNumber(-10);
      System.out.println("Thank you...");
    }
  }

Exception in thread "main" java.lang.ArithmeticException: ERROR: Invalid Roll Number at com.javabytechie.throwkeyword.ThrowWithUncheckedException.validateRollNumber(ThrowWithUncheckedException.java:7) at com.javabytechie.throwkeyword.ThrowWithUncheckedException.main(ThrowWithUncheckedException.java:15)

As of now, we have seen uses of the throw keyword with checked and unchecked exceptions; now let's see an example of the throw keyword with a custom (user-defined) exception, as given below.

  // Custom Exception class
  class RollNumberNotFoundException extends Exception {
    public RollNumberNotFoundException(String msg) {
      super(msg);
    }
  }
  
  public class ThrowWithCustomException {
    public static void validateRollNumber(Integer rollNumber) throws RollNumberNotFoundException {
      if (rollNumber == null) {
        // throwing Custom exception if roll number is null
        throw new RollNumberNotFoundException("ERROR: Roll Number Not Found...");
      } else {
        System.out.println("Roll Number is valid and found.");
      }
    }
  
    public static void main(String args[]) {
      try {
        validateRollNumber(null);
      } catch (RollNumberNotFoundException e) {
        e.printStackTrace();
      }
      System.out.println("Thank you...");
    }
  }

com.javabytechie.throwkeyword.RollNumberNotFoundException: ERROR: Roll Number Not Found... at com.javabytechie.throwkeyword.ThrowWithCustomException.validateRollNumber(ThrowWithCustomException.java:7) at com.javabytechie.throwkeyword.ThrowWithCustomException.main(ThrowWithCustomException.java:15)
Thank you...

Rethrowing an Exception in Java

Rethrowing an exception was introduced in the Java 7 version. This feature allows us to explicitly re-throw the same exception from the catch block using the throw keyword. When the same exception object is re-thrown, it preserves the details of the original exception.

When to use: There might be a requirement where we want to catch an exception in the catch block and also want its caller to be notified about the exception. This is possible by rethrowing the exception using the throw statement.

  try
  {
    // Code that might throw Exception.
  }
  catch(Exception e) 
  {
  // Rethrow the same exception.
    throw e;
  }

throw Keyword in Java

Rethrowing an Exception in Java

Currently No Video available