Throw Keyword in Java

This Throw keyword is prominently used in the concept of Exception Handling. As the name suggests, the throw keyword is about throwing out an exception from the program to the compiler. Briefing out on exception is a type of error that a compiler pops out from the program in case any discrepancy occurs during the run time of the code. Using this throw keyword, we can define our exception by interpreting any cause of errors during the program’s run time.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Let us see more details of it below:

Syntax

The syntax of throw in Java is like below:

throw exception_type ;

or

throw instance;

How does Throw Keyword work in Java?

Here, we can check how the keyword is used and understand how the flow works through an example.

import java.util.Scanner;
public class Main
{
public static void main(String[] args) {
int c;
Scanner sc = new Scanner(System.in);
System.out.println("Enter value of A: ");
int a = sc.nextInt();
//Scanner b = new Scanner(System.in);
System.out.println("Enter value of B: ");
int b = sc.nextInt();
try {
c= a/b;
if(b==0)
{
throw new ArithmeticException();
}
System.out.println("Value of C is: " +c);
}
catch(ArithmeticException e) {
System.out.println("Caught this here");
}
finally {
}
System.out.println("Finally block is here");
}
}

Let’s deal with this with a classic and simple example of division by zero.

Analyzing the code below:

• Firstly, we imported the Scanner module to take the user input values.
• The user inputs two numbers, namely, ‘A’ and ‘B.’
• We declared a variable ‘C’ to store the quotient’s value after dividing the number ‘A’ by ‘B’.
• As the user can randomly give the numbers, we can think of a situation where a user can give the divisor as zero.
• Accepting that scenario, we write our division code in a try block.
• And writing if a condition that in case the ‘B’ value has zero, then we are throwing an Exception.
• Always follow “try” with a catch block.
• So, here we mention the exception we defined using a new command by keyword throw.
• The same exception is there caught, and we just printed out a statement below to clearly understand the flow of the try, throw, catch, and finally.
• And then, finally, we are declaring our finally block. As already known, the statements in this block are definitely going to execute.

Let’s check the output below.

Output 1: If the b value is not a zero.

The absence of executed try, throw, and catch blocks is noticeable due to the non-zero ‘B’ value. In the end, the block is executed regardless of the exception creation.

Output 2: If the b value is zero.

The highlighted part ensures the exception is successfully thrown and caught by the catch block.

So, let’s see an example below.

Example:

Let us see how we can throw multiple exceptions in a single program.

public class Main
{
public static void main(String[] args) {
String sun[] = {"chocolate", "honey", "sugar", "sweet", "bitter"};
String h = null;
try {
for (int i=0; i sun.length)
{
throw new ArrayIndexOutOfBoundsException();
}
System.out.println(sun[i]);
}
}
catch(ArrayIndexOutOfBoundsException ae)
{
System.out.println("Inside array index out of bounds exception catch block");
}
try{
sun[0]=h;
if (sun[0] == null)
{
throw new NullPointerException();
}
System.out.println("Value of sun[0] is: " +sun[0]);
}
catch(NullPointerException f)
{
System.out.println("Caught Null point exception");
}
finally {
System.out.println("executing finally");
}
}
}

Above, we used two different types of exceptions and throw keywords to interpret the program. Array index out of bound and Null pointer exception is what we used here in a single program.

Output:

Importance of Throw

This throw keyword would help us act as a bridge between try and catch blocks. It will help transfer the program’s control from the try block to the catch block.

Let me show you an example of how a program works with and without using the throw keyword.

public class Main
{
public static void main(String[] args) {
try {
int a = Integer.parseInt ("Happy") ;
System.out.println("Will this get printed?");
} catch(NumberFormatException e) {
System.out.println("Number format exception of catch block");
}
System.out.println("Priting after catch block");
}
}

We have written code without the throw keyword. But we used the code to try and catch the block, which is going to handle the exception. So, do you know the output of the above?

Expected right? So, it executed the code, found an exception, and the exception was caught.

Now, how does the code work when we insert our throw statement? Let’s see below.

public class Main
{
public static void main(String[] args) {
try {
int a = Integer.parseInt ("Happy") ;
throw new NumberFormatException();
System.out.println("Will this get printed?");
} catch(NumberFormatException e) {
System.out.println("Number format exception of catch block");
}
System.out.println("Priting after catch block");
}
}

Only the highlighted part is the change between the above two codes.

Output:

Yes, we have a compilation error as the print statement after the throw keyword is unreachable. We hope you understand exactly what “transferring the control from try to catch block” means through this example.

As an exercise, try removing the print statement after the throw the keyword and check how the program reacts.

Conclusion

So, this is how the throw command has come into the picture at the time of exception handling. I do notice a good difference between the THROW and THROWS keywords. Both are used with the concept of exceptions. We already know the concept, how and where we can use the “THROW” keyword. Just practice and try using it in different ways. Keep learning.

The above is the detailed content of Throw Keyword in Java. For more information, please follow other related articles on the PHP Chinese website!