Java Exception Handling

Error is a serious problem caused during the runtime execution of a program. It cannot be handled and recovered. Errors cause the program to terminate. For example, System Crash or Out of Memory.

Exception is an error which can disrupt the normal execution flow of a program and may cause termination of the program.

During the normal execution of a program, whenever an error is occurred, an exception object is created at runtime, the execution of the normal flow is stopped, and JRE(Java Runtime Environment) finds a suitable handler for that exception. The exception object contains information like Type of Exception, Line number of statement along with Method call hierarchy, etc. The process of creating an exception object and passing it to the suitable handler is called throwing the exception.

Since the exception is an object in Java, it has a Parent Class as well i.e. Throwable. Throwable further has 2 child classes i.e. Error, and Exception.

Error is a scenario which cannot be handled and results in the prompt termination of the program. Whereas, an Exception is a scenario which only halts the normal execution flow and terminates the program only if the scenario is not handled.

Exception further be classified into Checked and Runtime Exception.

Checked Exception - These are the type of exception which are anticipated during the time of writing the code. Adding informative log messages can help in debugging this type of exception. These are also called Compile Time Exception. Before compilation, compiler verifies whether the exception has been handled or not. If not, then compilation error is thrown.

Runtime Exception - This type of exception cannot be anticipated. Checking the data before processing can avoid this type of exception. These are also called Unchecked Exception.

Keywords:

• throws
• When we are explicitly throwing an exception in a method and not handling it, we use "throws" keyword to let the calling method know that there might be an exception which needs to be handled. In this case, the caller method can also use throws keyword and not handle the exception and let its caller method know about the exception.
• throw
• When we want to explicitly throw an exception, "throw" keyword is used.
• try - catch
• try- catch is basically a block of code used to handle exception. The statements which are prone to exception are placed inside a try block and a handler for those exception(s) is written inside the catch block. The catch block expects an parameter, i.e. the Type of Exception. We can have a try-catch block inside another try-catch block and we can also have multiple catch blocks for a single try block to catch different exceptions.
• finally
• There is an optional block of code used with try-catch block in Java Exception Handling called the "finally" block. Since exceptions halt the normal flow of execution, there might be some code which needs to be executed e.g. closing the files or database connections, if opened, etc. Those blocks of code are written in finally block. This block of code gets executed irrespective of the occurrence of the exception.

Points to remember:

• Catch and Finally blocks cannot be used without using Try block.
• Try block must have a supporting Catch and/or Finally block.
• Only one Finally block can be used with a Try-Catch block.
• When using multiple catch blocks with a single try block, the exceptions must be ordered on the basis of most specific to general.
• Finally block is not executed only if the program terminates abruptly(due to death of thread) or the program is explicitly terminated or there has been an exception in finally block as well.
• In case of nested try-catch blocks, if the catch block does not handle the exception, then the catch block of the parent try block is inspected for that exception, and if a match is found then that catch block is executed. But in case the parent try block also does not handle the exception, then a system generated exception is shown same as what we see when we do not handle the exception.
• Statements present in finally block execute even if control transfer statements like return, continue, and break are used in the try block.
• Error and RuntimeException are collectively known as Unchecked Exception.

In addition to using the Java built-in classes, we can create your own exception(both Checked Exception and Runtime Exception) according to the needs of your project. We can create a user defined checked exception by extending Exception class and we can extend RuntimeException class to create a user defined Runtime Exception.