There are three main categories of exceptions in Java: 1. Checked exceptions must be handled by the programmer and cannot be ignored. 2. Unchecked exceptions occur during runtime due to programming errors. They can be ignored. 3. Errors are problems beyond the programmer's control, like stack overflows, and are also ignored. Java uses five keywords to handle exceptions: try catches exceptions thrown within its block; catch handles caught exceptions; throw manually throws exceptions; throws declares exceptions a method may throw; and finally always executes regardless of exceptions. Programmers place exception-prone code in try blocks and use catch blocks to handle exceptions rationally.

1. 3/18/2019 Exception Handling: Your Guided Course Template
https://canvas.instructure.com/courses/1480238/pages/exception-handling?module_item_id=21012886 1/3
Excep on Handling
Exception: An exception is an unwanted or unexpected event, which occurs during the execution of a
program i.e. at run time, which disrupts the normal flow of the program’s instructions.
Exception-in-java.png
Some of these exceptions are caused by user error, others by programmer error, and others by physical
resources that have failed in some manner. Based on these, we have three categories of Exceptions.
You need to understand them to know how exception handling works in Java.
1. Checked exceptions: A checked exception is an exception that is checked (notified) by the compiler
at compilation-time, these are also called as compile time exceptions. These exceptions cannot
simply be ignored, the programmer should take care of (handle) these exceptions.
2. Unchecked exceptions: An unchecked exception is an exception that occurs at the time of
execution. These are also called as Runtime Exceptions. These include programming bugs, such as
logic errors or improper use of an API. Runtime exceptions are ignored at the time of compilation.
3. Errors: These are not exceptions at all, but problems that arise beyond the control of the user or the
programmer. Errors are typically ignored in your code because you can rarely do anything about an
error. For example, if a stack overflow occurs, an error will arise. They are also ignored at the time of
compilation.
Java Exception Keywords:
There are 5 keywords which are used in handling exceptions in Java.
Keyword Description
try
The "try" keyword is used to specify a block where we should place exception code. The try
block must be followed by either catch or finally. It means, we can't use try block alone.
catch
The "catch" block is used to handle the exception. It must be preceded by try block which
means we can't use catch block alone. It can be followed by finally block later.
finally
The "finally" block is used to execute the important code of the program. It is executed
whether an exception is handled or not.
throw The "throw" keyword is used to throw an exception.
throws
The "throws" keyword is used to declare exceptions. It doesn't throw an exception. It specifies
that there may occur an exception in the method. It is always used with method signature.

2. 3/18/2019 Exception Handling: Your Guided Course Template
https://canvas.instructure.com/courses/1480238/pages/exception-handling?module_item_id=21012886 2/3
Exception Handling:
Java exception handling is managed via five keywords: try, catch, throw, throws, and finally. Briefly, here
is how they work. Program statements that you think can raise exceptions are contained within a try
block. If an exception occurs within the try block, it is thrown. Your code can catch this exception (using
catch block) and handle it in some rational manner. System-generated exceptions are automatically
thrown by the Java run-time system. To manually throw an exception, use the keyword throw. Any
exception that is thrown out of a method must be specified as such by a throws clause. Any code that
absolutely must be executed after a try block completes is put in a finally block.
class Demo {
public static void main (String[] args) {
int[] arr = new int[4]; // array of size 4.
int i = arr[4]; // this statement causes an exception
System.out.println("Hi, I want to execute"); // the following statement will never
execute
}
}
Output :
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
at Demo.main(Demo.java:9)
Explanation : In the above example an array is defined with size i.e. you can access elements only from
index 0 to 3. But you trying to access the elements at index 4(by mistake) that’s why it is throwing an
exception.In this case, JVM terminates the program abnormally. The statement System.out.println(“Hi, I
want to execute”); will never execute. To execute it, we must handled the exception using try-catch.
Hence to continue normal flow of the program, we need try-catch clause.
Note:
In a method, there can be more than one statements that might throw exception, So put all these
statements within its own try block and provide separate exception handler within own catch block for
each of them.
If an exception occurs within the try block, that exception is handled by the exception handler
associated with it. To associate exception handler, we must put catch block after it. There can be
more than one exception handlers. Each catch block is a exception handler that handles the
exception of the type indicated by its argument. The argument, ExceptionType declares the type of
the exception that it can handle and must be the name of the class that inherits from Throwable class.
For each try block there can be zero or more catch blocks, but only one finally block.

3. 3/18/2019 Exception Handling: Your Guided Course Template
https://canvas.instructure.com/courses/1480238/pages/exception-handling?module_item_id=21012886 3/3
The finally block is optional.It always gets executed whether an exception occurred in try block or not
. If exception occurs, then it will be executed after try and catch blocks. And if exception does not
occur then it will be executed after the try block. The finally block in java is used to put important
codes such as clean up code e.g. closing the file or closing the connection.