packtpublishing/learn-java-with-projects

1. Overall shape

This repository is not a single application; it is a chapter-by-chapter code companion for a Java book. Each .java file is a small, runnable example, and most folders correspond directly to a chapter topic or an exercise/project from that chapter.

2. Primary architectural boundary: chapter isolation

The main organizing unit is the chapter directory (ch1 through ch17). Chapters are intentionally decoupled from one another: code in one chapter generally does not form a shared library consumed by another. That means the architecture is closer to a learning lab than a production system, with many independent entry points rather than one central service.

3. Foundations layer: chapters 1–7

The early chapters focus on language basics: Hello World, variables, casting, operators, conditionals, loops, methods, and simple project-style exercises. The “project” subfolders in these chapters contain small mini-applications such as ProfileGenerator, DinoMealPlanner, TaskAllocationSystem, DinoTracker, and MesozoicEdenAssistant. These are still self-contained command-line programs, but they introduce the idea of combining multiple classes and input/output flows.

4. Object-oriented modeling layer: chapters 8–10

Chapters 8–10 move into encapsulation, enums, records, inheritance, polymorphism, and interfaces. You can see this in supporting model classes such as Person, Dog, Pig, Book, FictionBook, Vehicle, Employee, Ticket, and Dinosaur. Chapter 10 specifically explores interface features like default, private, static, and sealed interfaces, showing how type hierarchies are structured and constrained.

5. Exceptions and resource handling: chapter 11

Chapter 11 centers on exception handling and file cleanup. Files like InvalidAgeException, ReadFileExample, WriteFileExample, and FileResourceCleanup indicate the boundary between normal program flow and failure handling. This chapter is where the repository starts interacting with the filesystem in a more explicit way.

6. Core library usage: chapter 12

Chapter 12 covers common Java APIs such as dates, collections, scanners, strings, and immutability. It also includes a small data file, ages.txt, which is used as input for file-reading examples. Architecturally, this chapter is about moving from syntax into standard-library-driven data processing.

7. Generics and type-safe abstractions: chapter 13

Chapter 13 appears to focus on generics and reusable domain models, again using Dinosaur, DinosaurFood, and Vehicle examples. The exercises here suggest an emphasis on parameterized types and compile-time safety rather than new runtime components.

8. Functional programming layer: chapters 14–16

Chapters 14–16 introduce lambdas, method references, streams, optional values, primitive streams, and parallel streams. These chapters shift the architecture from imperative step-by-step code to pipeline-based processing. The main boundary here is between source data and stream pipelines that transform, filter, map, and collect results. Files such as cats.txt and the stream-processing classes support that dataflow.

9. Concurrency layer: chapter 17

Chapter 17 is the concurrency section, with examples of threads, runnable tasks, atomicity, deadlock, livelock, starvation, and race conditions. The dataraceandlock, dataraceandsynchronized, examplethreadclass, and examplerunnableinterface subfolders show different concurrency models and synchronization strategies. The main architectural concern here is shared mutable state and how access to it is coordinated.

10. Data and runtime model

The repo uses a few standalone text files (input.txt, output.txt, ages.txt, cats.txt) as local data sources for I/O and stream exercises. There is no database, web server, message broker, or external API integration. Everything runs locally on Java 21+, typically as console applications with chapter-specific main methods.

11. Exercises as parallel tracks

Nearly every chapter has an exercises folder. These are not separate subsystems so much as alternate implementations or practice variations of the chapter’s concepts. They reinforce the same architectural boundaries as the main examples: small, isolated, command-line programs.

12. Repository-level tooling and conventions

The repository is intentionally lightweight: no build framework or application container is central to the architecture. The presence of .gitkeep, .empty, and an IntelliJ .iml file suggests the repo is organized primarily for IDE-based exploration and direct compilation/run of individual source files.