Java.Core.What does the throws keyword mean?

What Does the throws Keyword Mean in Java?

The throws keyword in Java is used in a method signature to declare that the method might throw one or more exceptions. It does not throw an exception itself but informs the caller that an exception may be thrown.

---

1. Syntax of throws

returnType methodName(parameters) throws ExceptionType1, ExceptionType2 {
    // Method code
}

• ExceptionType1, ExceptionType2 must be checked exceptions or RuntimeException.
• The method does not handle the exception, but it warns the caller to handle it.

---

2. Difference Between throw and throws

Feature	throw	throws
Purpose	Used inside a method to forcefully throw an exception	Used in the method signature to declare exceptions
Exception Handling	Requires an instance of Throwable (new Exception("msg"))	Does not throw an exception but tells the caller it might occur
Location	Inside method body	In the method declaration
Usage	throw new IOException("Error");	void myMethod() throws IOException {}

✅ Example: throw vs. throws

class Example {
    // Declaring an exception using throws
    public static void riskyMethod() throws IllegalAccessException {
        throw new IllegalAccessException("Access denied!"); // Forcing an exception
    }

    public static void main(String[] args) {
        try {
            riskyMethod(); // Must handle or declare
        } catch (IllegalAccessException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
}

3. When to Use throws

✅ Use throws when a method does not handle a checked exception and passes it to the caller.
✅ Use throws for methods that perform risky operations (e.g., file handling, networking, database operations).

---

4. Example: Using throws to Declare Exceptions

✅ Without Handling (Using throws)

import java.io.*;

public class ThrowsExample {
    public static void readFile() throws IOException {
        FileReader file = new FileReader("test.txt"); // May throw FileNotFoundException
        BufferedReader br = new BufferedReader(file);
        System.out.println(br.readLine());
    }

    public static void main(String[] args) {
        try {
            readFile(); // Must handle exception
        } catch (IOException e) {
            System.out.println("Handled: " + e.getMessage());
        }
    }
}

✅ With Handling (Using try-catch Instead)

public class TryCatchExample {
    public static void readFile() {
        try {
            FileReader file = new FileReader("test.txt");
            BufferedReader br = new BufferedReader(file);
            System.out.println(br.readLine());
        } catch (IOException e) {
            System.out.println("Handled inside method: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        readFile(); // No need to handle again
    }
}

5. Multiple Exceptions with throws

You can declare multiple exceptions separated by commas.

✅ Example: Declaring Multiple Exceptions

import java.io.*;

public class MultipleThrowsExample {
    public static void processFile() throws IOException, SQLException {
        FileReader file = new FileReader("test.txt"); // May throw IOException
        throw new SQLException("Database error!"); // Manually throwing exception
    }

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

6. Can throws Be Used with Unchecked Exceptions?

Yes! But it’s optional because unchecked exceptions (RuntimeException and its subclasses) do not require handling.

✅ Example: Using throws with an Unchecked Exception

public class UncheckedExample {
    public static void riskyMethod() throws ArithmeticException {
        throw new ArithmeticException("Divide by zero error!");
    }

    public static void main(String[] args) {
        riskyMethod(); // No try-catch required, but program will crash if not handled
    }
}

🛠 Best Practice: Avoid using throws for unchecked exceptions unless necessary.

7. Summary: When to Use throws

Scenario	Use throws?
Method performs risky operations (I/O, DB, network)	✅ Yes
The method does not want to handle a checked exception	✅ Yes
You want the caller to handle the exception instead	✅ Yes
For unchecked exceptions (RuntimeException)	❌ Not necessary

---

Final Thoughts

✔ Use throws to declare checked exceptions in the method signature.
✔ Use throw inside methods to manually trigger exceptions.
✔ Multiple exceptions can be declared using throws.
✔ Avoid using throws for unchecked exceptions unless necessary.