Difference between throw and throws?

In Java, throw and throws are used in exception handling, but they serve different purposes. Here’s a detailed explanation of each:

throw

• Purpose: Used to explicitly throw an exception from a method or block of code.
• Syntax: throw new ExceptionType("Error message");
• Usage: When you want to signal an error condition to be handled elsewhere, you use throw to create and throw an instance of an exception. The control is transferred to the nearest catch block that can handle the exception or the calling method if not handled locally.

public void validateAge(int age) {
    if (age < 18) {
        throw new IllegalArgumentException("Age must be at least 18.");
    }
}

In this example, if the age is less than 18, an IllegalArgumentException is thrown.

throws

• Purpose: Used in method declarations to indicate that the method can throw certain exceptions, which need to be handled by the calling method.
• Syntax: public void method() throws ExceptionType1, ExceptionType2 { ... }
• Usage: When a method declares that it throws one or more exceptions, it means that the method is not handling those exceptions internally. Instead, it is the responsibility of the caller of this method to handle them. This is often used for checked exceptions that must be handled or declared in the method signature.

public void readFile(String filePath) throws IOException {
    FileReader fileReader = new FileReader(filePath);
    // Code that may throw IOException
}

Key Differences

• Scope:

  • throw is used to explicitly throw an exception from within a method or block of code.
  • throws is used in the method signature to declare that a method can throw specific exceptions.

• Declaration vs. Execution:

  • throw is used when the exception is actually thrown during the execution of code.
  • throws is used to declare potential exceptions that a method may throw, but does not handle them.

• Example of Combined Usage:

public void processFile(String filePath) throws IOException {
    if (filePath == null) {
        throw new IllegalArgumentException("File path cannot be null.");
    }
    // Assuming a method that may throw IOException
    readFile(filePath);
}

public void readFile(String filePath) throws IOException {
    FileReader fileReader = new FileReader(filePath);
    // Code that may throw IOException
}

Here, processFile method uses throw to handle an invalid argument and throws to declare that it may throw IOException from the readFile method.