How to throw exception in Java? [SOLVED]


Bashir Alam

JAVA

Java is a popular programming language that provides a range of operators and tools to help developers write robust and error-free code. One such operator is the throw operator, which is used to throw an exception in a Java program. In this article, we will explore what the throw operator is, how it works, and how it can be used in Java programs.

 

What is a throw operator in Java?

The throw operator in Java is used to throw an exception in a Java program. It is used to indicate that an error or exception condition has occurred in the program that cannot be handled by the program itself. The throw operator is followed by an instance of the exception class that describes the error condition.

When the throw operator is executed, the program stops executing at that point and jumps to the nearest exception handler that can catch the thrown exception. If there is no exception handler to catch the thrown exception, the program terminates with an error message.

The throw operator is an essential feature of Java's exception-handling mechanism. It allows developers to write more robust and error-free code by detecting and handling errors and exceptions at runtime.

To use the throw operator in Java, we need to create an instance of the exception class that describes the error condition. This is typically done using the new keyword to create a new object of the exception class. Once the exception object has been created, we can use the throw keyword to throw the exception.

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

throw new ExceptionClass("Exception message");

Here, "ExceptionClass" is the name of the exception class, and "Exception message" is a string that provides a description of the exception.

 

How to use the throw operator in Java?

To use the throw operator in Java, we need to follow the following steps:

  • Create an instance of the exception class: The first step is to create an instance of the exception class that describes the error or exception condition. This is typically done using the new keyword to create a new object of the exception class.
  • Use the throw keyword: Once the exception object has been created, we can use the throw keyword to throw the exception. The throw keyword causes the Java runtime system to terminate the current execution path and jump to the nearest exception handler that can catch the thrown exception.
  • Catch the thrown exception: Finally, the thrown exception should be caught by an exception handler using a try-catch block. This allows the program to handle the exception gracefully and continue execution, rather than terminating abruptly.

Let's look at an example of how to use the throw operator in Java:

public class Main {
    public static void main(String[] args) {
      int x = 10;
      int y = 0;
  
      if (y==0) {
        throw new ArithmeticException("Cannot divide by zero. The y value should be greater than 0");
      }
      else{
        int result = x / y;
        System.out.println("Result: " + result);
      }
      
    }
  }

In this example, we are trying to divide a number by zero, which is not a valid operation. If the value of "y" is 0, the program will throw an "ArithmeticException" with the message "Cannot divide by zero. The y value should be greater than 0". The following is the output of the program:

Exception in thread "main" java.lang.ArithmeticException: Cannot divide by zero. The y value should be greater than 0
        at Main.main(Main.java:7)

As you can see, the throw keyword has thrown the message for getting an error:

 

Example-1: Custom exception handling using throw operator

We can create our own exception class by extending the Exception class in Java. This allows us to define our own custom exceptions that can be thrown and caught in our program.

class InvalidInputException extends Exception {
    public InvalidInputException(String errorMessage) {
        super(errorMessage);
    }
}

public class Main {
    public static void main(String[] args) {
        int input = -1;
        
        try {
            if (input < 0) {
                throw new InvalidInputException("Invalid input: " + input);
            }
        } catch (InvalidInputException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Output:

Error: Invalid input: -1

In this example, we define a custom exception class "InvalidInputException" that extends the Exception class. We then use the throw operator to throw an instance of this exception if the input value is less than 0. The thrown exception is caught by an exception handler that prints an error message with the exception message.

 

Example-2: NullPointerException

The NullPointerException is a built-in exception class in Java that is thrown when a program tries to use a null reference. We can use the throw operator to throw this exception when we encounter null references in our program.

public class Main {
    public static void main(String[] args) {
        String str = null;
        
        try {
            if (str == null) {
                throw new NullPointerException("String reference is null");
            }
        } catch (NullPointerException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Output:

Error: String reference is null

In this example, we created a null reference for the string "str". We then used the throw operator to throw a NullPointerException if the value of "str" is null. The thrown exception is caught by an exception handler that prints an error message with the exception message.

 

Example-3: ArrayIndexOutOfBoundsException

The ArrayIndexOutOfBoundsException is a built-in exception class in Java that is thrown when a program tries to access an array element with an invalid index. We can use the throw operator to throw this exception when we encounter invalid array indices in our program.

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int index = 3;
        
        try {
            if (index < 0 || index >= arr.length) {
                throw new ArrayIndexOutOfBoundsException("Invalid array index: " + index);
            }
            
            System.out.println("Array element at index " + index + " is " + arr[index]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Output:

Error: Invalid array index: 3

In this example, we created an array "arr" and an index "index" that is out of bounds for the array. We used the throw operator to throw an ArrayIndexOutOfBoundsException if the value of "index" is less than 0 or greater than or equal to the length of the array. The thrown exception is caught by an exception handler that prints an error message with the exception message.

 

Frequently Asked question related to throw operator in Java

What is the purpose of the throw keyword in Java?

The throw keyword is used to manually throw an exception in Java.

 

What is an exception in Java?

An exception is an event that occurs during the execution of a program that disrupts the normal flow of the program's instructions.

 

When should I use the throw keyword in Java?

You should use the throw keyword in Java when you encounter an error condition in your program and want to throw an exception to indicate the error.

 

How do I define a custom exception in Java?

To define a custom exception in Java, you can create a new class that extends the Exception class and add any additional properties or methods that you need.

 

What happens when an exception is thrown in Java?

When an exception is thrown in Java, the normal flow of the program is interrupted and the program looks for an appropriate exception handler to handle the exception.

 

Can I throw multiple exceptions in a single method in Java?

Yes, you can throw multiple exceptions in a single method in Java by separating them with a comma.

 

Can I throw an exception without a try-catch block in Java?

Yes, you can throw an exception without a try-catch block in Java, but you will need to add a throws clause to the method signature to indicate that the method can throw an exception.

 

What is the difference between the throw and throws keywords in Java?

The throw keyword is used to manually throw an exception in Java, while the throws keyword is used to declare that a method can throw one or more exceptions.

 

Summary

In summary, the throw operator in Java is a powerful tool for handling errors and exceptions in our programs. We can use the throw operator to throw built-in or custom exception classes when we encounter error conditions in our programs. These exceptions can then be caught and handled by exception handlers to ensure that our programs run smoothly and do not terminate abruptly.

 

Further Reading

Exception handling in java

 

Views: 0

Bashir Alam

He is a Computer Science graduate from the University of Central Asia, currently employed as a full-time Machine Learning Engineer at uExel. His expertise lies in OCR, text extraction, data preprocessing, and predictive models. You can reach out to him on his Linkedin or check his projects on GitHub page.

Can't find what you're searching for? Let us assist you.

Enter your query below, and we'll provide instant results tailored to your needs.

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

Buy GoLinuxCloud a Coffee

For any other feedbacks or questions you can send mail to admin@golinuxcloud.com

Thank You for your support!!

Leave a Comment


We try to offer easy-to-follow guides and tips on various topics such as Linux, Cloud Computing, Programming Languages, Ethical Hacking and much more.

Programming Languages

JavaScript

Python

Golang

Node.js

Java

Laravel