← Back to Home

Module 1: Creating Exceptions

Module Overview

Learn how to create and use custom exceptions in Java applications. Understand when and why to implement your own exception classes to better handle errors.

Learning Objectives

Examine whether to throw an existing exception or implement a new exception for a given error case
Design and implement an exception that describes an error case specific to a service
Produce a unique serialVersionUID when creating a new exception type
Design and implement an exception class hierarchy for a code base
Outline when to chain (or wrap) an exception to hide implementation details from the caller
Explain why making custom exceptions can be helpful in the debugging process
Explain how to create chain (or wrapping) exceptions
Explain how to define error cases given a set of requirements
Outline the public constructors of the Exception class
Understand that it is a good practice to provide an Exception subclass with the same public constructor signatures as the base java.lang.Exception class

Video Content: Overview of Throwing and Writing Exceptions

This video introduces the fundamentals of custom exceptions in Java. When standard exceptions don't adequately describe your error cases, creating custom exceptions can improve code clarity and debugging.

public class ResourceNotFoundException extends Exception {
    private static final long serialVersionUID = 1L;
    
    public ResourceNotFoundException() {
        super();
    }
    
    public ResourceNotFoundException(String message) {
        super(message);
    }
    
    public ResourceNotFoundException(String message, Throwable cause) {
        super(message, cause);
    }
    
    public ResourceNotFoundException(Throwable cause) {
        super(cause);
    }
}

This example shows a custom exception that extends the standard Exception class, including the recommended constructor signatures that match the base Exception class. The serialVersionUID is essential for serialization compatibility.

Video Content: Designing Custom Exceptions

This video explores the process of designing an effective custom exception hierarchy for your application. A well-designed exception hierarchy helps organize error cases and provides meaningful context to callers.

// Base exception for the service
public class ServiceException extends Exception {
    private static final long serialVersionUID = 1L;
    
    public ServiceException(String message) {
        super(message);
    }
    
    public ServiceException(String message, Throwable cause) {
        super(message, cause);
    }
}

// More specific exception extending the base
public class InvalidInputException extends ServiceException {
    private static final long serialVersionUID = 2L;
    
    public InvalidInputException(String message) {
        super(message);
    }
    
    // Example of exception chaining (wrapping)
    public InvalidInputException(String message, Throwable cause) {
        super(message, cause);
    }
}

This code demonstrates how to create a hierarchy of exceptions with a base service exception and more specific child exceptions. Exception chaining (wrapping) is shown, which helps preserve the original cause while presenting a more appropriate exception to the caller.

Video Content: Sprint 14 Creating Exceptions Overview

This video provides a comprehensive overview of the Sprint 14 material on custom exceptions, bringing together the concepts from the previous videos and showing their application in real-world scenarios.

// Using custom exceptions in application code
public class UserService {
    public User findUserById(String userId) throws UserNotFoundException {
        User user = userRepository.findById(userId);
        
        if (user == null) {
            throw new UserNotFoundException("User with ID " + userId + " not found");
        }
        
        return user;
    }
    
    public void updateUser(User user) throws InvalidUserDataException {
        try {
            validateUser(user);
            userRepository.save(user);
        } catch (ValidationException e) {
            // Example of exception chaining - wrapping a low-level exception
            // in a more appropriate high-level exception
            throw new InvalidUserDataException("Invalid user data", e);
        }
    }
}