Why is "throws Exception" necessary when calling a function?
checked-exceptions, exception, java, throws, unhandled-exception
Solution
In Java, as you may know, exceptions can be categorized into two: One that needs the `throws` clause or must be handled if you don't specify one and another one that doesn't. Now, see the following figure:
In Java, you can throw anything that extends the `Throwable` class. However, you don't need to specify a `throws` clause for all classes. Specifically, classes that are either an `Error` or `RuntimeException` or any of the subclasses of these two. In your case `Exception` is not a subclass of an `Error` or `RuntimeException`. So, it is a checked exception and must be specified in the `throws` clause, if you don't handle that particular exception. That is why you needed the `throws` clause.
From Java Tutorial:
An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions.
Now, as you know exceptions are classified into two: checked and unchecked. Why these classification?
Checked Exception: They are used to represent problems that can be recovered during the execution of the program. They usually are not the programmer's fault. For example, a file specified by user is not readable, or no network connection available, etc., In all these cases, our program doesn't need to exit, instead it can take actions like alerting the user, or go into a fallback mechanism(like offline working when network not available), etc.
Unchecked Exceptions: They again can be divided into two: Errors and RuntimeExceptions. One reason for them to be unchecked is that they are numerous in number, and required to handle all of them will clutter our program and reduce its clarity. The other reason is:
Runtime Exceptions: They usually happen due to a fault by the programmer. For example, if an `ArithmeticException` of division by zero occurs or an `ArrayIndexOutOfBoundsException` occurs, it is because we are not careful enough in our coding. They happen usually because some errors in our program logic. So, they must be cleared before our program enters into production mode. They are unchecked in the sense that, our program must fail when it occurs, so that we programmers can resolve it at the time of development and testing itself.
Errors: Errors are situations from which usually the program cannot recover. For example, if a `StackOverflowError` occurs, our program cannot do much, such as increase the size of program's function calling stack. Or if an `OutOfMemoryError` occurs, we cannot do much to increase the amount of RAM available to our program. In such cases, it is better to exit the program. That is why they are made unchecked.
For detailed information see:
- Unchecked Exceptions — The Controversy
- The Catch or Specify Requirement
Problem
``` class throwseg1 { void show() throws Exception { throw new Exception("my.own.Exception"); } void show2() throws Exception // Why throws is necessary here ? { show(); } void show3() throws Exception // Why throws is necessary here ? { show2(); } public static void main(String s[]) throws Exception // Why throws is necessary here ? { throwseg1 o1 = new throwseg1(); o1.show3(); } } ``` Why compiler reports that methods `show2()`, `show3()`, and `main()` have unreported exception Exception that must be caught or declared to be thrown when I remove `throws Exception` from these methods?