Advanced Java Course

Lesson 1 • JVM Internals and Architecture

Covers class loading, bytecode execution, and memory regions. Provides the mental model needed to reason about performance and runtime behaviour throughout the course.

Lesson 2 • Build Systems: Maven and Gradle

Teaches dependency management, lifecycle phases, and multi-module projects. Enables reproducible builds essential for professional team environments.

Lesson 3 • Modern Java Version Features

Surveys language enhancements from Java 11 through Java 21. Ensures learners write idiomatic, up-to-date code in all subsequent chapters.

Lesson 1 • Garbage Collection Tuning

Analyses GC logs, selects collectors, and tunes heap sizing. Reduces pause times and throughput loss caused by suboptimal GC configuration.

Lesson 2 • Application-Level Optimisations

Applies object pooling, caching, and data structure selection strategies. Translates profiling findings into concrete code-level performance improvements.

Lesson 3 • Benchmarking with JMH

Writes reliable microbenchmarks using Java Microbenchmark Harness. Prevents common pitfalls like dead-code elimination and JIT warm-up skewing results.

Lesson 4 • CPU Profiling and Hotspot Analysis

Profiles CPU usage with async-profiler and flame graphs. Directs optimisation effort to the code paths that actually consume execution time.

Lesson 1 • SOLID Principles in Practice

Applies each SOLID principle to realistic Java code examples. Builds the design vocabulary used throughout advanced pattern and architecture chapters.

Lesson 2 • Composition Over Inheritance

Demonstrates delegation, decorator, and strategy patterns as inheritance alternatives. Reduces coupling in designs built upon in later architecture chapters.

Lesson 3 • Design Patterns Deep Dive

Implements creational, structural, and behavioural GoF patterns in Java. Provides reusable solutions referenced throughout enterprise and framework chapters.

Lesson 4 • Interfaces vs. Abstract Classes

Contrasts default methods, functional interfaces, and abstract templates. Guides correct choice between abstraction mechanisms in complex hierarchies.

Lesson 1 • Bounded Type Parameters

Applies upper and lower bounds to constrain type parameters. Enables writing algorithms that operate on type hierarchies safely.

Lesson 2 • Generic Classes and Methods

Defines parameterised types and generic method signatures. Establishes the foundation for understanding bounded types and wildcard variance.

Lesson 3 • Type Erasure and Reification

Explains how the compiler removes type information at runtime. Prevents common pitfalls like unchecked casts and illegal instanceof checks.

Lesson 1 • Core Functional Interfaces

Explores Function, Predicate, Consumer, Supplier, and their variants. Enables composing reusable behavioural building blocks across application layers.

Lesson 2 • Stream API Pipelines

Builds lazy intermediate and terminal operation pipelines on collections. Demonstrates how streams replace loops while improving readability and composability.

Lesson 3 • Optional and Null Safety

Replaces null checks with Optional chaining and functional transformations. Reduces NullPointerExceptions and integrates cleanly with stream pipelines.

Lesson 4 • Collectors and Grouping

Uses built-in and custom Collectors for grouping, partitioning, and joining. Enables complex aggregation logic expressed in a single pipeline expression.

Lesson 1 • Synchronisation and Visibility

Applies synchronised blocks, volatile, and the Java Memory Model. Prevents data races and visibility bugs in shared-state concurrent code.

Lesson 2 • Virtual Threads and Structured Concurrency

Introduces Project Loom virtual threads and StructuredTaskScope. Enables high-throughput I/O-bound concurrency with near-sequential code structure.

Lesson 3 • Thread Fundamentals and Lifecycle

Explains thread creation, states, and scheduling. Provides the baseline understanding required before introducing locks and concurrent data structures.

Lesson 4 • Executor Framework and Thread Pools

Configures thread pools, submits tasks, and handles futures. Decouples task submission from execution strategy in production-grade applications.

Lesson 5 • Concurrent Collections and Utilities

Leverages ConcurrentHashMap, BlockingQueue, and synchronisation barriers. Replaces manual locking with purpose-built thread-safe data structures.

Lesson 1 • Modern File System API

Applies java.nio.file Path, Files, and WatchService for file operations. Replaces legacy File API with a more expressive and platform-consistent interface.

Lesson 2 • Non-Blocking I/O with Selectors

Uses Selector, SelectionKey, and non-blocking SocketChannel. Supports thousands of concurrent connections in a single-threaded event loop.

Lesson 3 • Classic I/O Streams

Covers InputStream, OutputStream, Reader, Writer, and buffering. Establishes the stream abstraction model before introducing NIO's channel-buffer model.

Lesson 4 • Network Programming Fundamentals

Implements TCP and UDP communication using Socket and DatagramSocket. Provides the networking foundation for HTTP client and service integration work.

Lesson 1 • Dependency Injection with Spring

Configures Spring IoC container, bean scopes, and lifecycle hooks. Establishes the application wiring model used across all subsequent framework sections.

Lesson 2 • Data Persistence with JPA and Hibernate

Maps entities, configures relationships, and manages transactions. Provides the ORM foundation for building data-driven enterprise applications.

Lesson 3 • Spring Boot Application Structure

Bootstraps auto-configured Spring Boot apps with embedded servers. Enables rapid production-ready application scaffolding with minimal boilerplate.

Lesson 4 • Building RESTful APIs with Spring MVC

Implements controllers, request mapping, validation, and error handling. Produces well-structured HTTP APIs consumed by front-end and microservice clients.

Lesson 5 • Security Fundamentals with Spring Security

Configures authentication, authorisation, and JWT token validation. Protects REST endpoints against unauthorised access in production deployments.