Creating Custom Exceptions in Java

Introduction to Custom Exceptions in Java

In Java, exceptions are used to handle errors and other exceptional events that occur during program execution. While Java provides a rich set of built-in exceptions (e.g., NullPointerException, IOException), there are scenarios where these exceptions may not adequately describe the problem. In such cases, developers can create custom exceptions to represent specific application-level errors.

Custom exceptions improve code readability, maintainability, and provide more meaningful error messages tailored to the application's needs.

Steps to Create a Custom Exception in Java

​Creating a custom exception involves extending the Exception class (for checked exceptions) or the RuntimeException class (for unchecked exceptions). Below are the steps:

• Define the Custom Exception Class:
  
  • Extend theExceptionclass for checked exceptions orRuntimeExceptionfor unchecked exceptions.
  • Provide constructors to initialize the exception with custom messages or causes.
• Throw the Custom Exception:
  • Use the throw keyword to explicitly throw the custom exception when a specific condition is met.​
    
• Handle the Custom Exception:
  • Use a try-catch block to handle the custom exception.
  
  

Example: Creating a Custom Checked Exception

​// Step 1: Define the custom exception
class InvalidAgeException extends Exception {
public InvalidAgeException(String message) {
super(message);
}
}

// Step 2: Throw the custom exception
public class CustomExceptionExample {
public void validateAge(int age) throws InvalidAgeException {
if (age < 18) {
throw new InvalidAgeException("Age must be 18 or above.");
}
        System.out.println("Age is valid.");
}

public static void main(String[] args) {
        CustomExceptionExample example = new CustomExceptionExample();
        try {
            example.validateAge(16); // This will throw the exception
} catch (InvalidAgeException e) {
            System.out.println("Caught Exception: " + e.getMessage());
}
    }
}

Example: Creating a Custom Unchecked Exception

​// Step 1: Define the custom exception
class NegativeNumberException extends RuntimeException {
public NegativeNumberException(String message) {
super(message);
}
}

// Step 2: Throw the custom exception
public class CustomUncheckedExceptionExample {
public void checkNumber(int number) {
if (number < 0) {
throw new NegativeNumberException("Number cannot be negative.");
}
        System.out.println("Number is valid.");
}

public static void main(String[] args) {
        CustomUncheckedExceptionExample example = new CustomUncheckedExceptionExample();
        try {
            example.checkNumber(-5); // This will throw the exception
} catch (NegativeNumberException e) {
            System.out.println("Caught Exception: " + e.getMessage());
}
    }
}

Key Differences Between Checked and Unchecked Exceptions

​

Best Practices for Creating Custom Exceptions

• Meaningful Names: Use descriptive names for custom exceptions to clearly indicate the error.
• Custom Messages: Provide detailed error messages to help identify the issue.
• Extend the Right Class: Use Exception for checked exceptions and RuntimeException for unchecked exceptions.
• Avoid Overuse: Only create custom exceptions when built-in exceptions are insufficient.
• Document Exceptions: Clearly document when and why the custom exception is thrown.