Exception handling in Java is extremely important because it helps maintain the normal, desired flow of the program even when unexpected events occur. If exceptions are not handled, programs may crash or requests may fail.

In this course, you will analyze the syntax of exception handling, case by case, to understand what could happen in each variation. You’ll start by looking into multiple cases using the try-catch block, things like what happens if you throw multiple exceptions.

You’ll then look at exception handling and use cases around the syntax of the usage of finally, another popular exception block.

Lastly, you’ll experiment with the throw block and creating your own custom exceptions. By the end of this course, you will have a good grip on exception handling and its various syntaxes and use cases.

Java Exception Handling Made Simple

All exceptions come under a parent class, named `Exception` class.



The exceptions are categorized into two types:
* Checked exceptions
* Unchecked exceptions

## Checked exceptions
These exceptions are checked by the compiler during compilation. Therefore, they are also known as compile-time exceptions.

> **These exceptions must be handled or declared.**



Some common checked exceptions are:


### IOException
This exception is thrown when there is a problem regarding reading and writing files.

```java

 try{
     FileInputStream in = new FileInputStream("file.txt");
    }catch (IOException e){
      System.out.print(e);
    }
```
If the file is not found, it will throw a FileNotFoundException, which is a subclass of IOException.

### ClassNotFoundException
This exception is thrown when the JVM tries to load the class but doesn't find it in the classpath.

```java
 try{
     Class.forName("MYclass");
    }catch (ClassNotFoundException e){
      e.printStackTrace();
    }


In this lesson, we'll walk through different types of exceptions.

__default

Understanding Different Types of Exceptions

Types of exceptions

Checked exceptions

IOException