Top 10 Key Differences Between Throw Vs Throws In Java (+Examples)

0 min read

In Java, exception handling is a crucial aspect of writing robust and error-free programs. Two commonly used keywords in this context are throw and throws, both of which deal with exceptions but serve different purposes. While throw is used to explicitly throw an exception within a method, throws is used to declare exceptions that a method might throw. Understanding their differences is essential for writing clean and efficient exception-handling code. In this article, we will explore throw and throws in detail, their syntax, use cases, and key differences with examples.

Key Differences Between throw Vs throws In Java

Here's a detailed comparison between throw and throws in Java programming:

Understanding throw Keyword In Java

The throw keyword in Java is used to explicitly throw an exception during program execution. It allows us to trigger exceptions manually based on specific conditions, ensuring proper error handling and program stability.

Uses Of throw In Java

1. Custom Exception Handling – Helps create user-defined exceptions.
2. Input Validation – Stops execution if input is invalid.
3. Forcefully Terminating Execution – Halts execution when an error occurs.
4. Propagation of Exceptions – Throws exceptions to be handled at a higher level.

Syntax Of throw In Java

throw new ExceptionType("Error message");

Here:

• throw → Used to throw an exception.
• new → Creates an instance of the exception.
• ExceptionType → The type of exception being thrown (e.g., IllegalArgumentException, IOException).
• "Error message" → An optional message describing the error.

Code Example:

            public class ThrowExample {
    static void checkAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("Access denied - You must be 18 or older.");
        } else {
            System.out.println("Access granted - You are old enough!");
        }
    }

    public static void main(String[] args) {
        checkAge(16);  // Throws an exception
        System.out.println("This line won't execute.");
    }
}

          

cHVibGljIGNsYXNzIFRocm93RXhhbXBsZSB7CiAgICBzdGF0aWMgdm9pZCBjaGVja0FnZShpbnQgYWdlKSB7CiAgICAgICAgaWYgKGFnZSA8IDE4KSB7CiAgICAgICAgICAgIHRocm93IG5ldyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24oIkFjY2VzcyBkZW5pZWQgLSBZb3UgbXVzdCBiZSAxOCBvciBvbGRlci4iKTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICBTeXN0ZW0ub3V0LnByaW50bG4oIkFjY2VzcyBncmFudGVkIC0gWW91IGFyZSBvbGQgZW5vdWdoISIpOwogICAgICAgIH0KICAgIH0KCiAgICBwdWJsaWMgc3RhdGljIHZvaWQgbWFpbihTdHJpbmdbXSBhcmdzKSB7CiAgICAgICAgY2hlY2tBZ2UoMTYpOyAgLy8gVGhyb3dzIGFuIGV4Y2VwdGlvbgogICAgICAgIFN5c3RlbS5vdXQucHJpbnRsbigiVGhpcyBsaW5lIHdvbid0IGV4ZWN1dGUuIik7CiAgICB9Cn0K

Output: 

Exception in thread "main" java.lang.IllegalArgumentException: Access denied - You must be 18 or older.
    at ThrowExample.checkAge(ThrowExample.java:4)
    at ThrowExample.main(ThrowExample.java:10)

Explanation:

In the above code example-

1. We define a class ThrowExample, which contains a static method checkAge(int age).
2. Inside checkAge, we check if the given age is less than 18:
• If age is below 18, we throw an IllegalArgumentException with the message "Access denied - You must be 18 or older."
• If age is 18 or above, we print "Access granted - You are old enough!"
3. In the main() method, we call checkAge(16), which is below 18.
4. Since checkAge(16) triggers an exception, program execution stops immediately.
5. The line "This line won't execute." is never printed because an unhandled exception terminates the program.

Understanding throws Keyword In Java

The throws keyword in Java is used in method signatures to declare that a method may throw exceptions. It informs the caller that the method might generate specific exceptions, which must be handled either with try-catch or propagated further.

Uses Of throws In Java

1. Exception Propagation – Passes exceptions to the calling method.
2. Simplifies Exception Handling – Avoids handling exceptions inside the method.
3. Declaring Checked Exceptions – Used to indicate that a method may throw checked exceptions.
4. Enhances Code Readability – Clearly states which exceptions a method might throw.

Syntax Of throws In Java

returnType methodName() throws ExceptionType {
    // Method body
}

Here: 

• returnType → The return type of the method (e.g., void, int).
• methodName() → The name of the method.
• throws → Declares the exceptions that the method may throw.
• ExceptionType → The type of exception(s) that might be thrown (e.g., IOException, SQLException).

Code Example:

            import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ThrowsExample {
    static void readFile() throws IOException {
        FileReader file = new FileReader("test.txt"); // May throw IOException
        System.out.println("File opened successfully.");
    }

    public static void main(String[] args) {
        try {
            readFile();
        } catch (IOException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

          

aW1wb3J0IGphdmEuaW8uRmlsZTsKaW1wb3J0IGphdmEuaW8uRmlsZVJlYWRlcjsKaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247CgpwdWJsaWMgY2xhc3MgVGhyb3dzRXhhbXBsZSB7CiAgICBzdGF0aWMgdm9pZCByZWFkRmlsZSgpIHRocm93cyBJT0V4Y2VwdGlvbiB7CiAgICAgICAgRmlsZVJlYWRlciBmaWxlID0gbmV3IEZpbGVSZWFkZXIoInRlc3QudHh0Iik7IC8vIE1heSB0aHJvdyBJT0V4Y2VwdGlvbgogICAgICAgIFN5c3RlbS5vdXQucHJpbnRsbigiRmlsZSBvcGVuZWQgc3VjY2Vzc2Z1bGx5LiIpOwogICAgfQoKICAgIHB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHsKICAgICAgICB0cnkgewogICAgICAgICAgICByZWFkRmlsZSgpOwogICAgICAgIH0gY2F0Y2ggKElPRXhjZXB0aW9uIGUpIHsKICAgICAgICAgICAgU3lzdGVtLm91dC5wcmludGxuKCJFeGNlcHRpb24gY2F1Z2h0OiAiICsgZS5nZXRNZXNzYWdlKCkpOwogICAgICAgIH0KICAgIH0KfQo=

Output: 

Exception caught: test.txt (No such file or directory)

Explanation:

In the above code example-

1. We define a class ThrowsExample, which contains a static method readFile().
2. The method readFile() declares throws IOException, indicating it may throw an IOException.
3. Inside readFile(), we attempt to open a file named "test.txt" using FileReader.
4. If the file does not exist or cannot be read, an IOException is thrown.
5. In the main() method, we call readFile() inside a try block to handle potential exceptions.
6. If an IOException occurs, the catch block catches it and prints "Exception caught: " followed by the error message.
7. If the file is successfully opened, "File opened successfully." is printed.

Important Points To Remember About throw And throws In Java

1. throw vs. throws

• throw is used inside a method to explicitly throw an exception.
• throws is used in the method signature to declare exceptions a method may throw.

2. Key Differences

• throw can only throw one exception at a time, while throws can declare multiple exceptions (comma-separated).
• throw must be followed by an exception object, whereas throws is followed by exception class names.

3. Exceptions Must Be Throwable

• Only instances of Throwable or its subclasses (Exception, Error) can be thrown.

4. Checked vs. Unchecked Exceptions

• throws is mandatory for checked exceptions (IOException, SQLException).
• Unchecked exceptions (NullPointerException, ArithmeticException) do not require throws.

5. Handling Exceptions

• If a method declares a checked exception using throws, the caller must handle it using try-catch or propagate it further.
• throw immediately terminates execution unless caught in a try-catch block.

6. Best Practices

• Always provide meaningful exception messages to aid debugging.
• Avoid excessive use of throws—handle exceptions where appropriate.
• Use custom exceptions for better error categorization in large projects.

Conclusion

Understanding the differences between throw and throws in Java is essential for effective exception handling. The throw keyword is used to explicitly throw an exception within a method, while throws is used to declare exceptions that a method might propagate. Proper usage of these keywords ensures robust error handling, improving code reliability and maintainability.

By following best practices—such as handling checked exceptions appropriately, using meaningful exception messages, and avoiding unnecessary throws declarations—developers can write cleaner, more maintainable Java programs. A well-structured approach to exception handling not only enhances program stability but also simplifies debugging and troubleshooting in complex applications.

Frequently Asked Questions

Q. What is the key difference between throw and throws?

The throw keyword is used inside a method or block to explicitly throw an exception at runtime. It requires an instance of an exception to be thrown. The throws keyword is used in the method signature to declare exceptions that a method might throw. It does not handle the exception but informs the caller that an exception may be thrown.

Q. Can a method use both throw and throws together?

Yes, a method can use both throw and throws. The throws keyword declares the exceptions that may be thrown, while the throw keyword is used to actually throw the exception inside the method. For Example-

void checkAge(int age) throws IllegalArgumentException {
    if (age < 18) {
        throw new IllegalArgumentException("Not eligible!");
    }
}

Q. Can throw be used to throw multiple exceptions at once?

No, throw can only throw one exception at a time. If multiple exceptions need to be thrown based on different conditions, separate if statements with throw must be used.

Q. Is it mandatory to handle exceptions declared using throws?

Yes, if a method declares a checked exception using throws, the calling method must handle it using try-catch or propagate it further. For unchecked exceptions, handling is optional.

Q. What happens if we do not handle an exception thrown using throw?

If an exception is thrown and not handled, it propagates up the call stack. If no method in the call stack handles the exception, the program terminates abruptly, and the JVM prints a stack trace.

Q. Can throws be used with multiple exceptions?

Yes, a method can declare multiple exceptions using throws, separated by commas.

void processFile() throws IOException, SQLException {
    // Method implementation
}

Suggested Reads:

1. Convert String To Date In Java | 3 Different Ways With Examples
2. Final, Finally & Finalize In Java | 15+ Differences With Examples
3. Super Keyword In Java | Definition, Applications & More (+Examples)
4. How To Find LCM Of Two Numbers In Java? Simplified With Examples
5. How To Find GCD Of Two Numbers In Java? All Methods With Examples
6. Volatile Keyword In Java | Syntax, Working, Uses & More (+Examples)