Difference Between throw and throws in Java

Difference Between throw and throws in Java

In Java, exception handling is an essential aspect of building robust and error-resilient applications. Java provides several keywords to handle exceptions effectively, and among them, throw and throws are often confused by beginners. Although they appear similar, they serve different purposes in the context of exception handling.

In this blog post, we will delve deep into the differences between throw and throws in Java, explaining their syntax, use cases, and examples to help you distinguish between the two with ease.

1. Overview of throw and throws

throw: Used to explicitly throw an exception from a method or a block of code.
throws: Declares exceptions that a method might throw, allowing the caller of the method to handle them.

2. Syntax and Usage

throw Statement

The throw keyword is followed by an instance of Throwable (usually an exception object).

throw new ArithmeticException("Divide by zero");

throws Clause

The throws keyword is used in method declarations to specify what exceptions may be thrown.

public void readFile() throws IOException {
    // code that might throw IOException
}

3. Key Differences Between throw and throws

Feature	`throw`	`throws`
Purpose	To actually throw an exception	To declare potential exceptions
Location	Within a method or block	In method signature
Follows	Single exception object	One or multiple exception classes (comma-separated)
Used With	Exception object	Method declaration
Execution Flow	Causes immediate transfer of control to catch block	Informs the caller to handle the exception

4. Example Demonstration

Using throw

public class ThrowExample {
    public static void main(String[] args) {
        int age = 15;
        if (age < 18) {
            throw new ArithmeticException("Access denied - You must be at least 18 years old.");
        } else {
            System.out.println("Access granted.");
        }
    }
}

Output:

Exception in thread "main" java.lang.ArithmeticException: Access denied - You must be at least 18 years old.

Using throws

import java.io.*;

public class ThrowsExample {
    public static void readFile() throws IOException {
        FileReader file = new FileReader("nonexistent.txt");
        BufferedReader fileInput = new BufferedReader(file);

        for (int counter = 0; counter < 3; counter++)
            System.out.println(fileInput.readLine());

        fileInput.close();
    }

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

Output:

Caught an IOException: nonexistent.txt (No such file or directory)

5. Common Mistakes to Avoid

Using throw without an exception object.
Assuming throws will actually throw the exception.
Not handling exceptions declared with throws in the caller method.

6. Summary Table

Keyword	Action Performed	Used Inside	Followed By
throw	Actually throws an exception	Method body	Instance of Throwable
throws	Declares possible exceptions	Method signature	Class names of exceptions

7. Conclusion

Understanding the distinction between throw and throws is crucial for writing clean and effective Java code.

Use throw when you want to manually trigger an exception.
Use throws when your method might throw a checked exception and you want to delegate exception handling to the calling method.

Mastering these concepts is key to becoming a proficient Java developer, especially when working on large-scale applications where exception management plays a vital role.