What are Throw and Throws in Java?

Java, originally Oak named and later renamed after the refreshing coffee Java, is the basis of modern programming used by about nine million developers worldwide and runs on more than 95 percent of desktops in businesses. The scale of its adoption shows how adaptable and reliable it can be. For instance, amongst many other things, it has robust facilities for error control using ‘throws’ and ‘throw’ statements that handle run-time exceptions or errors. In this blog post, we shall take a deep look into ‘throw’ and ‘throws’ in Java programming to see how these features make coding easier regarding reliability and maintainability as illustrated through live examples. Get set to become an expert in strong Java programming!

Watch this Java video by Intellipaat:

What is the throw Keyword in Java?

The throw keyword is used to directly throw an exception, which means the programmer can identify an exceptional condition within the program flow, allowing for custom error handling. To handle the exception thrown, the try-catch block is used. The flow of execution of a program switches from the try block to the nearest catch block when an exception is thrown.

In other words, when you expect something to go wrong in your code, you put it inside a try-catch block. If something goes wrong (an exception is thrown), the program jumps to the catch block to deal with it.

Syntax of Java throw 

The syntax for using the throw keyword in Java is as follows:

throw exceptionObject;

Here, “exceptionObject” is an instance of a class that extends the “Throwable class” (base class for all exceptions and errors) either directly or indirectly, such as Exception or Error. This syntax is used to generate and throw an exception during the execution of a program.

Example of Java throw

Let’s understand how the throw keyword is used in a program with the help of a simple example:

public class Test {
    public static long getFactorial(final int num) {
        if (num >= 0 && num < 15) {
            long fact = 1;
            for (int i = 1; i <= num; i++) {
                fact *= I;
            }
            return fact;
        } else {
            // throw new exception here
            throw new IllegalArgumentException("Please provide a valid argument");
        }
    }
    public static void main(String[] args) {
        try {
            System.out.println(getFactorial(6));
            System.out.println(getFactorial(-6));
        } catch (IllegalArgumentException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

Output:

720

Exception caught: Please provide a valid argument

In this Java example, we are calculating the factorial of a positive integer. The method takes an integer ‘num’ as input and returns the factorial of ‘num’. The method checks whether the provided input is within the valid range, and if not, it throws an ‘IllegalArgumentException’ with the message “Please provide a valid argument.” 

What is the throws Keyword in Java?

The “throws” keyword in Java tells you what kinds of problems a method might have while it’s running. It’s like knowing what could go wrong.

The exception is caught in a try-catch block, and an error message is printed. When a method uses the ‘throws’ keyword in its declaration, it’s a way of informing the code that the method might come across an exception while it’s running. 

The throws keyword is used to prevent compile time errors. The throws keyword can be used to assign the caller (which could be a method or a JVM) the task of handling exceptions.

Syntax of Java throws

The syntax for using the throw keyword in Java is as given below:

returnType methodName(parameters) throws exceptionType1, exceptionType2, ... {

There can be more than one type of exception that a method might throw. These are represented by exceptionType1 and exceptionType2 in the syntax. 

Example of Java throws

Let’s consider a simple example where a method calculates the division of two numbers. It can throw an exception if the divisor is zero, as the result will be infinite. In this case, we’ll use the ‘throws’ keyword to indicate that the method might throw an ‘ArithmeticException’.

public class DivisionCalculator {
    // A method that performs division and throws ArithmeticException if the divisor is zero
    public static double divide(int dividend, int divisor) throws ArithmeticException {
        if (divisor == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return (double) dividend/divisor;
    }
    public static void main(String[] args) {
        // Using the divide method and handling the potential exception
        try {
            double result = divide(10, 2);
            System.out.println("Result: " + result);
            // Attempting to divide by zero (potential exception)
            result = divide(5, 0); // This line will throw an ArithmeticException
            System.out.println("Result: " + result); // This line won't be reached due to the exception
        } catch (ArithmeticException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

In this example, the ‘divide’ method takes two parameters (dividend and divisor) and performs the division. If the divisor is zero, it throws an ‘ArithmeticException’ with the message “Cannot divide by zero.” 

The output of this program is as follows:

Result: 5.0

Error: Cannot divide by zero

Difference Between throw and throws in Java

The following table summarizes the differences between throw and throws in Java:

This table provides a concise comparison of the key differences between throw and throws in Java.

Conclusion

Knowing how to use ‘throw’ and ‘throws’ is important for handling errors in Java. These keywords help developers build strong applications that can deal with problems gracefully, making the software more reliable and easier to maintain. By using ‘throw’ and ‘throws’ wisely, developers can improve how their Java programs handle errors, making the user experience smoother.

FAQs