# Exception Handling Part 03

## Custom Exceptions

1.  Creating a checked Exception
    
    Points To Remember while creating a checked Exception:
    
    1.  When we create our custom checked exception it should always inherit the exception class
        
    2.  The exception class will by default inherit the throwable object
        
    
    example:
    
    ```java
    import java.util.ArrayList;
    import java.util.Arrays;
    
    // create a checked exception class
    class CustomException extends Exception {
      public CustomException(String message) {
        // call the constructor of Exception class
        super(message);
      }
    }
    
    class Main {
    
      ArrayList<String> languages = new ArrayList<>(Arrays.asList("Java", "Python", "JavaScript"));
    
      // check the exception condition
      public void checkLanguage(String language) throws CustomException {
    
        // throw exception if language already present in ArrayList
        if(languages.contains(language)) {
          throw new CustomException(language + " already exists");
        }
        else {
          // insert language to ArrayList
          languages.add(language);
          System.out.println(language + " is added to the ArrayList");
        }
      }
    
      public static void main(String[] args) {
    
        // create object of Main class
        Main obj = new Main();
    
        // exception is handled using try...catch
        try {
          obj.checkLanguage("Swift");
          obj.checkLanguage("Java");
        }
    
        catch(CustomException e) {
          System.out.println("[" + e + "] Exception Occured");
        }
      }
    }
    ```
    

2.  Creating a custom unchecked exception
    
    Points to remember while creating a custom unchecked exception:
    
    **Unchecked exceptions** inherit from the **Error** class or the **RuntimeException** class. Many programmers feel that we cannot handle these exceptions in our programs because they represent the type of errors from which programs cannot be expected to recover while the program is running. When an unchecked exception is thrown, it is usually caused by **misuse of code**, **passing a null** or otherwise **incorrect argument**.
    

EXAMPLE:

```java
public class CustomUncheckedException extends RuntimeException {
   /*
   * Required when we want to add a custom message when throwing the exception
   * as throw new CustomUncheckedException(" Custom Unchecked Exception ");
   */
   public CustomUncheckedException(String message) {
      // calling super invokes the constructors of all super classes
      // which helps to create the complete stacktrace.
      super(message);
   }
   /*
   * Required when we want to wrap the exception generated inside the catch block and rethrow it
   * as catch(ArrayIndexOutOfBoundsException e) {
      * throw new CustomUncheckedException(e);
   * }
   */
   public CustomUncheckedException(Throwable cause) {
      // call appropriate parent constructor
      super(cause);
   }
   /*
   * Required when we want both the above
   * as catch(ArrayIndexOutOfBoundsException e) {
      * throw new CustomUncheckedException(e, "File not found");
   * }
   */
   public CustomUncheckedException(String message, Throwable throwable) {
      // call appropriate parent constructor
      super(message, throwable);
   }
}
```