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

throw — actively throws (raises) an exception instance. throws — declares that a method might throw certain exceptions (a contract with callers).

Analogy: throw is like actually calling the fire department because there is a fire. throws is like putting a sign on your door that says "fire may occur here" — it warns people but doesn't start anything.

throw keyword:

• Used inside a method body to actually throw an exception object.
• Creates an exception instance and hands it to the JVM.
• Followed by an exception object (e.g., new Exception("msg")).
• After throw, the code in that method stops executing.
• Only ONE exception can be thrown at a time.

1public void validate(int age) {
2    if (age < 0) {
3        throw new IllegalArgumentException("Age cannot be negative: " + age);
4    }
5    if (age < 18) {
6        throw new ArithmeticException("Must be 18 or older");
7    }
8    System.out.println("Valid age: " + age);
9}
10
11// Re-throwing an exception:
12public void process() throws IOException {
13    try {
14        readFile();
15    } catch (IOException e) {
16        System.err.println("Logging error: " + e.getMessage());
17        throw e; // Re-throw to let caller handle it
18    }
19}

throws keyword:

• Used in the method signature (after the parameter list).
• Declares which checked exceptions the method might throw.
• Acts as a warning to the caller: "handle or declare these exceptions."
• Does NOT actually throw anything itself.
• Can declare multiple exceptions separated by commas.

1// Method declaration with throws
2public void readFile(String path) throws IOException, SecurityException {
3    File file = new File(path);
4    if (!file.exists()) {
5        throw new FileNotFoundException("File not found: " + path);
6    }
7    // Read file...
8    FileInputStream fis = new FileInputStream(file);
9}
10
11// Caller must handle OR declare:
12public void loadData() {
13    try {
14        readFile("/data/config.txt");
15    } catch (IOException e) {
16        System.err.println("Failed to load: " + e.getMessage());
17    } catch (SecurityException e) {
18        System.err.println("Permission denied");
19    }
20}

Key differences:

• throw — actual action, throws an exception object.
• throws — declaration only, in method signature.
• throw — inside method body.
• throws — in method header.
• throw — can throw any exception (checked or unchecked).
• throws — mainly used with checked exceptions.

Why it matters:

• Checked exceptions enforce the "handle or declare" rule — the compiler ensures you deal with potential errors.
• Unchecked exceptions (RuntimeException) don't require throws in the signature.
• Proper use of throw + throws makes your error handling explicit and testable.

Common mistakes:

• Using throw without throws when a checked exception needs to propagate.
• Declaring throws Exception as a catch-all (lazy — narrow it down).
• Throwing exceptions in constructors without declaring throws.
• Forgetting to re-throw after catching and logging.