The Project | About Us | Contribute | Donations | License

HOME

In Java, exceptions are a powerful mechanism for handling errors and other exceptional events. While Java provides a rich set of built-in exceptions, there are times when you need to create your own custom exceptions to handle specific situations in your application. This section will guide you through the process of creating and using custom exceptions in Java.

Key Concepts

Exception Hierarchy: Understanding the hierarchy of exceptions in Java.
Creating Custom Exceptions: How to define your own exception classes.
Throwing Custom Exceptions: How to throw custom exceptions in your code.
Catching Custom Exceptions: How to handle custom exceptions using try-catch blocks.

Exception Hierarchy

In Java, all exceptions are derived from the Throwable class. The hierarchy is as follows:

Throwable
- Exception
  - RuntimeException
  - Other checked exceptions
- Error

Custom exceptions typically extend the Exception class or one of its subclasses.

Creating Custom Exceptions

To create a custom exception, you need to define a new class that extends Exception or RuntimeException. Here is an example:

// Custom checked exception
public class CustomCheckedException extends Exception {
    public CustomCheckedException(String message) {
        super(message);
    }
}

// Custom unchecked exception
public class CustomUncheckedException extends RuntimeException {
    public CustomUncheckedException(String message) {
        super(message);
    }
}

Explanation

CustomCheckedException: This is a checked exception because it extends Exception. Checked exceptions must be declared in a method's throws clause if they can be thrown by the method.
CustomUncheckedException: This is an unchecked exception because it extends RuntimeException. Unchecked exceptions do not need to be declared in a method's throws clause.

Throwing Custom Exceptions

You can throw custom exceptions using the throw keyword. Here is an example:

public class CustomExceptionDemo {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (CustomCheckedException e) {
            System.out.println("Caught CustomCheckedException: " + e.getMessage());
        }
    }

    public static void validateAge(int age) throws CustomCheckedException {
        if (age < 18) {
            throw new CustomCheckedException("Age must be 18 or older.");
        }
    }
}

Explanation

validateAge: This method checks if the age is less than 18. If it is, it throws a CustomCheckedException with a specific message.
main: The main method calls validateAge inside a try-catch block to handle the custom exception.

Catching Custom Exceptions

Custom exceptions are caught using the same try-catch mechanism as built-in exceptions. Here is an example:

public class CustomExceptionDemo {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (CustomCheckedException e) {
            System.out.println("Caught CustomCheckedException: " + e.getMessage());
        }

        try {
            validateName(null);
        } catch (CustomUncheckedException e) {
            System.out.println("Caught CustomUncheckedException: " + e.getMessage());
        }
    }

    public static void validateAge(int age) throws CustomCheckedException {
        if (age < 18) {
            throw new CustomCheckedException("Age must be 18 or older.");
        }
    }

    public static void validateName(String name) {
        if (name == null) {
            throw new CustomUncheckedException("Name cannot be null.");
        }
    }
}

Explanation

validateName: This method checks if the name is null. If it is, it throws a CustomUncheckedException with a specific message.
main: The main method calls validateName inside a try-catch block to handle the custom unchecked exception.

Practical Exercise

Exercise

Create a custom checked exception called InvalidEmailException.
Create a method validateEmail that throws InvalidEmailException if the email does not contain an "@" symbol.
Write a main method to test the validateEmail method.

Solution

// Custom checked exception
public class InvalidEmailException extends Exception {
    public InvalidEmailException(String message) {
        super(message);
    }
}

public class EmailValidator {
    public static void main(String[] args) {
        try {
            validateEmail("invalidemail.com");
        } catch (InvalidEmailException e) {
            System.out.println("Caught InvalidEmailException: " + e.getMessage());
        }
    }

    public static void validateEmail(String email) throws InvalidEmailException {
        if (!email.contains("@")) {
            throw new InvalidEmailException("Email must contain '@' symbol.");
        }
    }
}

Explanation

InvalidEmailException: This custom checked exception is thrown when the email does not contain an "@" symbol.
validateEmail: This method checks if the email contains an "@" symbol. If not, it throws an InvalidEmailException.
main: The main method tests the validateEmail method and catches the custom exception.

Common Mistakes and Tips

Not Declaring Checked Exceptions: Remember to declare checked exceptions in the method's throws clause.
Using Unchecked Exceptions for Recoverable Errors: Use checked exceptions for recoverable errors and unchecked exceptions for programming errors.
Not Providing Meaningful Messages: Always provide meaningful messages when throwing exceptions to make debugging easier.

Conclusion

Custom exceptions in Java allow you to create specific error handling mechanisms tailored to your application's needs. By understanding how to create, throw, and catch custom exceptions, you can make your code more robust and maintainable. In the next section, we will explore the finally block and its role in exception handling.

Custom Exceptions

Key Concepts

Exception Hierarchy

Creating Custom Exceptions

Explanation

Throwing Custom Exceptions

Explanation

Catching Custom Exceptions

Explanation

Practical Exercise

Exercise

Solution

Explanation

Common Mistakes and Tips

Conclusion

Java Programming Course

Module 1: Introduction to Java

Module 2: Control Flow

Module 3: Object-Oriented Programming

Module 4: Advanced Object-Oriented Programming

Module 5: Data Structures and Collections

Module 6: Exception Handling

Module 7: File I/O

Module 8: Multithreading and Concurrency

Module 9: Networking

Module 10: Advanced Topics

Module 11: Java Frameworks and Libraries

Module 12: Building Real-World Applications