Both throw
and throws
are concepts of exception handling in Java. The throws
keyword is used to declare which exceptions can be thrown from a method, while the throw
keyword is used to explicitly throw an exception within a method or block of code.
The throws
keyword is used in a method signature and declares which exceptions can be thrown from a method. The throws
keyword can be useful for propagating exceptions in the call stack and allows exceptions to not necessarily be handled within the method that declares these exceptions.
On the other hand, the throw
keyword is used within a method body, or any block of code, and is used to explicitly throw a single exception. The throw
keyword can be useful for throwing exceptions based on certain conditions within a code block and for throwing custom exceptions.
Java Throws Keyword
The throws
keyword in Java is used to declare exceptions that can occur during the execution of a program. For any method that can throw exceptions, it is mandatory to use the throws
keyword to list the exceptions that can be thrown. The throws
keyword provides information about the exceptions to the programmer as well as to the caller of the method that throws the exceptions.
The throws
keyword allows exceptions to be propagated in the call stack. When a method declares that it throws an exception, it is not required to handle the exception. The caller of a method that throws exceptions is required to handle the exceptions (or throw them to its caller and so on) so that the flow of the program can be maintained.
Only checked exceptions are required to be thrown using the throws
keyword. Unchecked exceptions don’t need to be thrown or handled explicitly in code.
Java Throws Example
Here is an example of a method that throws an exception, which is handled by the caller of the method:
public static void writeToFile() throws IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter("myFile.txt"));
bw.write("Test");
bw.close();
}
public static void main(String[] args) {
try {
writeToFile();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
In the above example, the “writeToFile” method throws an IOException and declares it using the throws keyword to its callers. The “main” method calls the “writeToFile” method and handles the exception within a try-catch block, and prints the exception stack trace to the console.
Java Throws Syntax
The throws
syntax in Java is shown below:
type method (arguments) throws Exception1, Exception2, … { }
As seen in the syntax above, all exceptions that can be thrown by a method should be declared in the method signature using the throws
keyword. A method can throw multiple exceptions, which should be separated by a comma in the declaration.
Java Throw Keyword
The throw
keyword in Java is used for explicitly throwing a single exception. This can be from within a method or any block of code. Both checked and unchecked exceptions can be thrown using the throw
keyword.
When an exception is thrown using the throw
keyword, the flow of execution of the program is stopped and the control is transferred to the nearest enclosing try-catch block that matches the type of exception thrown. If no such match is found, the default exception handler terminates the program.
The throw
keyword is useful for throwing exceptions based on certain conditions e.g. if a user enters incorrect data. It is also useful for throwing custom exceptions specific to a program or application.
Unchecked exceptions can be propagated in the call stack using the throw
keyword in a method. Checked exceptions can be propagated using the throw keyword when the method that throws the exception declares it using the throws
keyword.
Java Throw Syntax
The throw
syntax in Java is shown below:
throw throwableObject;
A throwable object can be an instance or subclass of the Throwable class. All exceptions defined in Java are subclasses of Throwable.
Java Throw Example
private static List<Integer> integers = new ArrayList<Integer>();
public static void addInteger(Integer value) throws IllegalArgumentException {
if (integers.contains(value)) {
throw new IllegalArgumentException("Integer already added.");
}
integers.add(value);
}
public static void main(String[] args) {
try {
addInteger(1);
} catch (IllegalArgumentException iae) {
iae.printStackTrace();
}
}
In this example, the “addInteger” method throws an IllegalArgumentException using the throw keyword in case the “integers” ArrayList object already contains the integer passed.
Since IllegalArgumentException is a checked exception, it must be handled within the “addInteger” method or its caller. In this example, the “addInteger” method does not handle the exception and throws it to the caller using the throws
keyword.
Therefore the caller, “main”, has to handle the IllegalArgumentException using a try-catch block.
Java Throw vs Throws
The table below lists the difference between the throw
and throws
keywords in Java:
Throw | Throws |
---|---|
Used within a method (or constructor) | Used with method (or constructor) signature |
Used to throw an exception explicitly | Used to declare exceptions |
Can only throw a single exception | Can declare multiple exceptions |
Followed by a throwable instance | Followed by an exception class name |
Cannot be used to propagate checked exceptions by itself | Can be used to propagate checked exceptions by itself |
Track, Analyze and Manage Errors With Rollbar
Managing errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Rollbar can help throw Java exceptions as well as track, analyze, and manage errors in real-time to help you to proceed with more confidence. Try it today!