throw vs throws in Java

throw and throws in Java look almost identical but do different jobs. throw actually throws an exception right now. throws warns callers that a method might throw one. This guide explains both, when Java forces you to use throws, and how to handle what gets thrown.

First: what is an exception?

An exception is Java's way of saying "something went wrong and I can't carry on normally". Instead of returning a weird value, the method throws an exception object describing the problem. The program then jumps to the nearest code that catches it. If nothing catches it, the program stops and prints the error.

What is the difference between throw and throws?

One is an action; the other is a warning label. Compare them:

if (amount <= 0) {
    throw new IllegalArgumentException("Amount must be positive");
}

String readConfig(Path file) throws IOException {
    return Files.readString(file);
}

How do you use throw in Java?

Use throw when your code detects a problem it can't fix itself, such as invalid input:

public class Wallet {
    private double balance = 50.0;

    public void withdraw(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive, got " + amount);
        }
        if (amount > balance) {
            throw new IllegalStateException("Not enough money: balance is " + balance);
        }
        balance -= amount;       // only runs if no exception was thrown
    }
}

• throw new IllegalArgumentException(...) — creates an exception object with new and throws it immediately.
• Everything after a throw in that path is skipped, so the balance is never changed by a bad request.

How do you catch a thrown exception?

Wallet wallet = new Wallet();

try {
    wallet.withdraw(20);
    System.out.println("First withdrawal OK");
    wallet.withdraw(100);                       // throws
    System.out.println("This line never runs");
} catch (IllegalStateException e) {
    System.out.println("Problem: " + e.getMessage());
}
System.out.println("Program keeps going");

First withdrawal OK
Problem: Not enough money: balance is 30.0
Program keeps going

Checked vs unchecked exceptions

Whether you need throws depends on which kind of exception it is:

How do you use throws in Java?

Reading a file can fail with an IOException, which is checked. If your method doesn't catch it, you must declare it with throws. Otherwise the code won't compile:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class ConfigLoader {

    // ✘ Won't compile: unreported exception IOException; must be caught or declared to be thrown
    // static String load(Path file) {
    //     return Files.readString(file);
    // }

    // ✔ Option 1: declare it and let the caller decide
    static String load(Path file) throws IOException {
        return Files.readString(file);
    }

    // ✔ Option 2: handle it here
    static String loadOrDefault(Path file) {
        try {
            return Files.readString(file);
        } catch (IOException e) {
            return "defaults";
        }
    }

    public static void main(String[] args) {
        System.out.println(loadOrDefault(Path.of("missing.conf")));
        try {
            load(Path.of("missing.conf"));
        } catch (IOException e) {
            System.out.println("Caught: " + e.getClass().getSimpleName());
        }
    }
}

defaults
Caught: NoSuchFileException

NoSuchFileException is a subclass of IOException, so catch (IOException e) catches it.

Creating your own exception

A custom exception gives callers a precise type to catch:

public class InsufficientFundsException extends RuntimeException {
    public InsufficientFundsException(double needed, double available) {
        super("Need " + needed + " but only " + available + " available");
    }
}

// In Wallet.withdraw(...):
if (amount > balance) {
    throw new InsufficientFundsException(amount, balance);
}

Because it extends RuntimeException, it's unchecked and needs no throws. Extend Exception instead if you want callers to be forced to handle it. The super(...) call passes the message to the parent class (see the super keyword).

Common mistakes

• Writing throws inside a method body or throw in a signature. They're not interchangeable.
• Forgetting new: throw IllegalArgumentException("x") won't compile; you throw an object.
• Catching Exception and doing nothing. An empty catch hides bugs. At least log the error.
• Using exceptions for normal flow, such as ending a loop. They're for unexpected situations.

Quick recap

What's next?

Next, learn how Java stores groups of objects in the Collections Framework, or browse the full Java keywords list.