![Cover image for Throw & Throws - [OOP & Java #9]](https://media2.dev.to/dynamic/image/width=1000,height=420,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fi%2Fpszm43ezeqcg078gltg1.png)
Exceptions
Exceptions are things that worth special consideration. This could mean that the execution of some method is "exceptional" because it might result in errors.
We, therefore, handle exceptions in our program to avoid errors.
There are two main branches of exceptions, checked and unchecked exceptions.
Summary
| Exception | Checked | Unchecked |
|---|---|---|
| Error | Compile-time | Run-time |
| Occurrence | Anticipate and handle | Unanticipated |
| Example | IOException FileNotFoundException ... | NullPointerException ArithmeticException ... |
| Strategy | Must declare or catch | Result in bugs to be fixed |
Try-catch
One way to deal with known exceptions is to put dangerous code in a try-catch block.
try {
// Might result in FileNotFoundException
FileReader file = new FileReader(args[0]);
// any other code that might result in exceptions
} catch (FileNotFoundException e) {
// do something about the exception
}
When we catch an exception, we could resolve it by printing out some message to the caller, or we could simply throw the exception at the caller. Actively raising an exception is still considered a way of "handling" exceptions.
try {
// something dangerous here
} catch (IOException e) {
// simply throw exceptions
// can throw different exceptions
throw new NullPointerException("My exception message here");
}
Throw
The keyword throw is used to raise exceptions. It could be used within a catch block to resolve another exception. It could also be used whenever we would like to raise an exception.
// some method
public void test() {
throw new ArrayStoreException("Throwing it because I want to");
}
Throws
Instead of using try-catch, we could simply declare in the method signature that this method could throw some exceptions that callers must look out for. Note that we don't declare unchecked/run-time exceptions because they cannot be anticipated.
Let's see some code examples.
// might throw unchecked exceptions, which is typical
void willThrowUnchecked() {
// does some stuff
throw new NullPointerException("this is an unchecked exception");
}
// DON'T DO THIS, unchecked exceptions need not be declared
void willThrowUnchecked2() throws NullPointerException {
throw new NullPointerException("this is an unchecked exception");
}
// might throw a checked exception
void willThrowChecked() throws IOException {
// pretend that it might throw an exception
throw new IOException();
}
// DON'T DO THIS, checked exceptions must be declared
// will not compile
void willThrowChecked2() {
throw new IOException();
}
Unchecked exceptions
- The function call within this method body does not throw checked exceptions, hence ok to not do any handling.
// will compile
void useUnchecked() {
willThrowUnchecked();
}
- Unchecked exceptions need NOT be anticipated. No known checked exceptions anticipated. Hence ok to not do any handling.
// will compile
void useUnchecked2() {
willThrowUnchecked2();
}
- We can handle unchecked exceptions, if we want to
// will compile
void useUnchecked3() {
try {
willThrowUnchecked();
} catch (NullPointerException e) {
System.out.println("hello");
}
}
Checked exceptions
- If we don't handle checked exceptions, we are not allowed to use potentially dangerous methods.
// will not compile
void useChecked() {
willThrowChecked();
}
- We declare that the current method is dangerous, so whenever this method is called, the caller needs to handle it. we passed the responsibility to the caller of this method. This is considered "handling" exceptions as well.
// will compile
void useChecked2() throws IOException {
willThrowChecked();
}
- We handled the exception using try-catch, safe and sound.
// will compile
void useChecked3() {
try {
willThrowChecked();
} catch (IOException e) {
System.out.println("I handled it!");
}
- We handled it by throwing another exception, still safe.
// will compile
void useChecked4() {
try {
willThrowChecked();
} catch (IOException e) {
throw new NullPointerException("Hey there is a problem!");
}
}
- If we throw a checked exception as a response, we must declare it.
// will NOT compile
void useChecked4() {
try {
willThrowChecked();
} catch (IOException e) {
throw new IOException ("Hey there is a problem!");
}
}
// will compile
void useChecked4() throws IOException {
try {
willThrowChecked();
} catch (IOException e) {
throw new IOException ("Hey there is a problem!");
}
}
Throws vs Throw
The two keywords are not exactly comparable because they serve different purposes. They can co-exist in a single method. Hence, the usage of the two reserved words depend on the situation.
Summary
| Throws | Throw | |
|---|---|---|
| Purpose | To declare checked exceptions | To throw any exceptions |
| Usage | when the method body contains code that might throw checked exceptions | As a way to raise exceptions (both checked and unchecked) to the caller |
| Example | void test() throws IOException {} |
throw new NullPointerException("WRONG"); |
Top comments (0)