In this code-along, you will design and implement custom exceptions for a specific service scenario. You'll learn how to create meaningful exception hierarchies, implement proper constructors with serialVersionUID, and apply exception chaining techniques to preserve error context.
This exercise applies multiple learning objectives from Module 1, including designing service-specific exceptions, determining when to create new exceptions versus using existing ones, and implementing effective exception hierarchies that improve debugging and error handling.
This code-along introduces you to dependency injection with Dagger. You'll refactor tightly-coupled code to use dependency injection, significantly improving testability and flexibility. The exercise demonstrates how to identify dependencies, create appropriate modules and components, and implement constructor injection.
You'll gain practical experience with key Module 2 learning objectives including using a dependency injection framework, analyzing when to use singletons, identifying class dependencies, and visualizing dependency relationships. This hands-on approach helps solidify the advantages of dependency injection compared to direct instantiation.
Building on the foundation from Code-Along 2, this exercise explores advanced Dagger techniques including @Binds, component builders/factories, scopes, and multibinding. You'll implement more complex dependency scenarios with custom scopes and subcomponents to manage the lifetimes of different objects.
This code-along directly addresses Module 3 learning objectives by providing hands-on experience with complex dependency graphs, analyzing when objects should be scoped as singletons versus request-scoped, and implementing advanced dependency injection patterns that significantly improve application architecture.
In this code-along, you'll implement a custom linked list from scratch, understanding the internal structure and performance characteristics. You'll write key operations like addFirst, addLast, get, and remove, with a focus on analyzing the time complexity of each operation and understanding the trade-offs compared to array-based lists.
This hands-on exercise directly addresses Module 4 learning objectives by demonstrating why access by index in a linked list is O(n) while adding or removing from the beginning is O(1). You'll also gain practical experience in designing a class that efficiently maintains an ordered collection, and develop the ability to analyze when to choose LinkedList versus ArrayList for different scenarios.