In this tutorial, we will learn about how to throw an exception in Java. In Java, an Exception is a unique event that disrupts the normal execution flow of a program and signals an error or an exceptional condition. It represents a deviation from the expected behavior and serves as a mechanism for handling and recovering from unexpected situations.
In Java, you can throw an exception using the throw
keyword.
Throw Keyword in Java
Throwing an exception in Java involves using the throw
keyword to disrupt the normal flow of a program and indicate an error or exceptional condition. Here’s some following steps on how to throw an exception in Java:
- Select the appropriate exception class: Java provides a variety of exception classes for different types of errors or exceptional situations. You can choose from built-in exceptions like
NullPointerException
,IllegalArgumentException
,ArrayIndexOutOfBoundsException
, or create your own custom exception by extending theException
class. - Instantiate the exception: Create an instance of the chosen exception class using the
new
keyword. You can include a descriptive message to provide details about the exception if necessary. - Throw the exception: Use the
throw
keyword followed by the instance of the exception you created. This action will interrupt the regular program flow and transfer control to an appropriate exception handler.
By utilizing the throw
keyword, we gain control over the program’s execution flow and effectively communicate exceptional conditions or errors. This empowers us to handle and recover from unexpected situations by transferring control to an appropriate exception handler.
Syntax:
throw <exception>;
In the syntax, <exception>
refers to the instance of an exception that you want to throw. This can be a built-in exception class or a custom exception class that extends the base Exception
class.
Different Examples of Throw an Exception in Java
Example 1:
public class Example {
public static void main(String[] args) {
try {
throw new NullPointerException("Custom exception message");
} catch (NullPointerException e) {
System.out.println("Exception caught: " + e.getMessage());
}
}
}
Output:
Exception caught: Custom exception message
In this example, we actively employ the throw
keyword to throw a NullPointerException
by creating an instance of the exception class with a customized message. Subsequently, the catch
block is utilized to catch and handle the thrown exception.
Example 2:
public class Example {
public static void main(String[] args) {
try {
int age = -18;
if (age < 0) {
throw new IllegalArgumentException("Age cannot be negative.");
}
System.out.println("Age: " + age);
} catch (IllegalArgumentException e) {
System.out.println("Error: " + e.getMessage());
}
}
}
Output:
Error: Age cannot be negative.
In this example, we are checking the value of the age
variable. If the age is less than 0 (negative), we actively throw a IllegalArgumentException
by creating an instance of the exception class with a custom message stating that “Age cannot be negative.”
Difference between throw and throws keywords in Java
throw | throws | |
Functionality | The throw keyword is used to explicitly raise or throw an exception within a method. | The throws keyword is used in method declarations to specify the exceptions that a method might throw. |
Invocation | The throw keyword is used within the body of a method to throw an exception at a specific point. | The throws keyword appears in the method signature, indicating that the method might throw one or more exceptions. |
Handling | When an exception is thrown using the throw keyword, it must be caught and handled using try-catch blocks within the same method or in any higher-level method in the call stack | throws keyword indicates that the method does not handle those exceptions itself but instead passes the responsibility to the calling code to handle or propagate them further. |
Usage | It allows you to actively indicate exceptional conditions or errors and transfer control to an appropriate exception handler. | It is used to declare the types of exceptions that can be propagated to the calling code. |
Syntax | throw <exception>; | () throws { // Method body } |