throw vs throws

#Introduction

One of the first exception-handling questions in almost every Java interview is:

"What is the difference between throw and throws?"

Many developers answer: "throw throws an exception and throws declares it." While correct, this answer is incomplete. To answer confidently in a senior interview, you should understand:

• JVM behaviour
• Exception propagation
• Checked vs unchecked interactions
• Inheritance rules
• Method overriding
• Spring Boot usage
• Enterprise best practices

#What is throw?

throw is a keyword used to explicitly create and throw an exception object.

throw exceptionObject;

throw new RuntimeException("Invalid User");

#What is throws?

throws is used in the method declaration to indicate that the method may throw one or more exceptions.

returnType method() throws ExceptionType {
}

public void readFile() throws IOException {
}

Meaning: "I may throw IOException. The caller must handle it."

#Simple Comparison

#Examples

throw

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

throws

public void read() throws IOException {
    FileReader reader = new FileReader("test.txt");
}

#throw with Checked and Unchecked Exceptions

Checked exception, declared

public void upload() throws IOException {
    throw new IOException("Upload Failed");
}

Compilation succeeds because the checked exception is declared.

Missing throws

public void upload() {
    throw new IOException();
}

Unhandled exception type IOException

Reason: checked exceptions must be caught or declared using throws.

Unchecked exception

public void calculate() {
    throw new ArithmeticException();
}

No throws needed, because ArithmeticException → RuntimeException → unchecked.

#Can throw Throw null?

throw null;

Compilation: ✅ success. At runtime:

NullPointerException

The JVM attempts to throw a Throwable reference, finds null, and throws a NullPointerException instead.

#Multiple Exceptions

Multiple exceptions with throws

public void process() throws IOException, SQLException, ParseException {
}

A method may declare multiple exception types.

Can throw Throw Multiple Exceptions?

No. One throw statement throws only one exception object. If different exceptions are needed, use conditional logic:

if (type.equals("FILE")) {
    throw new IOException();
} else {
    throw new SQLException();
}

#Re-throwing and Wrapping

Re-throwing Exceptions

try {
    readFile();
} catch (IOException e) {
    throw e;
}

The same exception is propagated.

Wrapping Exceptions

Instead of re-throwing directly:

catch (IOException e) {
    throw new RuntimeException(e);
}

Better:

catch (IOException e) {
    throw new FileUploadException("Upload Failed", e);
}

This provides meaningful business context while preserving the original cause.

throw vs throws Together

public void save() throws IOException {
    throw new IOException("Disk Full");
}

#Constructors, Interfaces and Overriding

Constructor with throws

Constructors may also declare exceptions:

public Employee() throws IOException {
}

The caller must handle or declare the exception.

Interface Methods

interface Reader {
    void read() throws IOException;
}

Implementation:

class FileReaderImpl implements Reader {
    @Override
    public void read() throws IOException {
    }
}

The implementing class must follow the exception contract.

Method Overriding Rules

Parent:

void read() throws IOException {
}

Child:

void read() throws FileNotFoundException {   // ✅ Valid — narrower
}

void read() throws Exception {               // ❌ Invalid — broader
}

A child method cannot declare a broader checked exception than its parent.

#JVM Execution Flow

throw new IllegalArgumentException();

throw Inside catch

try {
    readFile();
} catch (IOException e) {
    throw new RuntimeException(e);
}

This is very common in enterprise applications.

#Spring Boot and Enterprise Usage

Spring Boot Example

public User findUser(Long id) {
    return repository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("User not found"));
}

Internally this does throw new UserNotFoundException("User not found");. No throws required because it extends RuntimeException.

Enterprise Example

Service layer:

public void uploadFile() {
    try {
        storage.upload();
    } catch (IOException e) {
        throw new FileUploadException("Unable to upload file", e);
    }
}

Controller layer:

@ExceptionHandler(FileUploadException.class)

This approach translates low-level exceptions into business-specific exceptions.