An exception is a divergence from an application’s normal behavior.

Exception in java follow a throw and catch mechanism. 

When something happens that is not expected at a particuler point in the program execution (e.g. not finding a file when trying to read a file), java stops the current execution flow and let us know by throwing an exception object.

We can handle this exception by catching the exception in the same method and try to recover from it, or catch it and rethrow it, or just leave the handling part to the caller of this method. If no one handle the exception, it is finally thrown to JVM and the program halts execution.

Some exceptions can be avoided with proper coding, but some are not within our control, and hence need to be handled.

Some advantages of Java's exception handling are:

• Error handling code is separated from the normal program function and hence it improves the program structure.

• The programmer can choose where to handle exceptions or whether to handle at all. We can handle this exception by catching the exception in the same method and try to recover from it, or catch it and rethrow it, or just leave the handling part to the caller of this method. 

• You can create youe own exception specific to your application.

Exception Hierarchy

The parent class for all exception related classes is the java.lang.Throwable class. 

Throwable has two children: Exception and Error. 

Exception and all its children are usually recoverrable and hence we can handle them and try to recover from them.

Exception and all its subclasses except RuntimeException are called checked excpetions. Java mandates that we need to handle checked exceptions.

RuntimeException and its subclasses are called unchecked exceptions or runtime exceptions. Handling of Runtime exceptions or unchecked exceptions are optional, and java doesn't mandate it. 

Usually there is nothing much we can do from within our program to recover from an error and hence it is recommended not to try to recover from error within the program. For example, consider the OutOfMemory error. You can’t do much from the program when system's memory is run out; instead you should restart the system or just application and try to optimize the program and system resources to avoid the error from occuring again. 

Any Throwable (Exception, RuntimeException, Error or any of their subclasses) can actually be handled the same way; however, handling checked exception is mandated, handling runtime exception is optional and handling error is not recommended. 

Exception hiararchy can be summarized as below.

Checked Exception v/s Runtime Exception

Exception and all its subclasses except RuntimeException are called as checked exceptions. RuntimeException and its subclasses are called unchecked exceptions. Java mandates that we need to handle checked exceptions. Handling of Runtime exceptions or unchecked exceptions are optional.

A checked exception is an exception for which the developer doesn’t have any control over the occurrences with the possibility of recovery. IOException is an example for a checked exception. IOException usually occurs when there is some problem with an IO device and the developer doesn’t have any control on that; but can try workarounds, like retries after waiting for some time. Therefore, the developer must handle it, either explicitly using try-catch block or say that it is being handled elsewhere through the use of throws clause in that method signature. Else program won't compile. 

A runtime exception is an exception that mostly represent a coding mistake. It is called unchecked exception because handling is optional. Instead of handling it, you should actually try to avoid it through better programming. NullPointerException is an example for an unchecked exception. A NullPointerException can be avoided by having proper null checks on variables before accessing them.