throw and throws in Java

In Java, throw and throws are keywords that are used for exception handling. They allow you to throw exceptions and propagate them up the call stack to be handled by the caller of the method. Here’s how throw and throws work:

throw Keyword

The throw keyword is used to throw an exception explicitly. When you use throw, you specify the exception that you want to throw, and the runtime system will look for a catch block that can handle the exception.

throw new Exception("Something went wrong");

In this example, we’re using throw to throw an instance of the Exception class with a message “Something went wrong”. When this code is executed, it will immediately exit the current method and look for a catch block that can handle the exception.

throws Keyword

The throws keyword is used to declare that a method may throw one or more exceptions. When you use throws, you’re telling the compiler that the method can throw an exception, and the caller of the method must handle the exception or propagate it further up the call stack.

public void readFile() throws FileNotFoundException {
    // code that may throw FileNotFoundException
}

In this example, we’re using throws to declare that the readFile() method may throw a FileNotFoundException. When you call this method, you must handle the exception or declare that the exception can be propagated further up the call stack.

Example of throw and throws

public void openFile(String filename) throws FileNotFoundException {
    if (filename == null) {
        throw new IllegalArgumentException("Filename cannot be null");
    }
    FileInputStream file = new FileInputStream(filename);
    // other code that uses the file
}

In this example, we’re using both throw and throws. The openFile() method takes a filename as an argument and may throw a FileNotFoundException. If the filename is null, we’re using throw to explicitly throw an IllegalArgumentException with a message “Filename cannot be null”. If the file exists, we’re creating a new FileInputStream object and doing some other operations with the file.

Rules for throw and throws

• You can use throw to throw an exception explicitly.
• You can use throws to declare that a method may throw one or more exceptions.
• When you use throw, the exception must be a subclass of the Throwable class.
• When you use throws, the exception type must be listed in the method signature, separated by commas if there are multiple exceptions.
• If a method declares that it throws an exception, the caller of the method must either handle the exception or declare that it can be propagated further up the call stack using throws.
• If a method throws a checked exception, it must be declared using throws.
• If a method throws an unchecked exception, it doesn’t need to be declared using throws.
• You can use throw and throws together to handle and propagate exceptions in your Java programs.

Conclusion

In Java, throw and throws are keywords that are used for exception handling. They allow you to throw exceptions and propagate them up the call stack to be handled by the caller of the method. By understanding the syntax and rules of throw and throws, you can write robust and error-free Java programs.