Java — Intermediate
Move from writing Java to engineering it: equality and immutability contracts, SOLID design, generics with wildcards, advanced collections, Collectors, exception architecture, testing depth, concurrency, async composition, repositories, layered architecture, and algorithms — capped by a layered expense-tracker capstone.
Who this course is for
Learners who finished Java — Beginner (or know its scope) and want to design, test, and structure maintainable Java applications — not just write more syntax.
What you will be able to do
- Design types with correct equals/hashCode contracts, immutability, and defensive copying
- Apply dependency inversion, composition, and sealed hierarchies to real design tradeoffs
- Write generic APIs with bounded types, wildcards, and PECS confidently
- Choose and combine collections with Comparable/Comparator and immutable views
- Transform data with Collectors: groupingBy, partitioningBy, toMap, teeing
- Architect errors with try-with-resources, exception boundaries, and custom hierarchies
- Read and write NIO.2 file code and hand-parse CSV/JSON safely
- Test like a professional: AAA, parameterized thinking, test doubles, regression nets
- Reason about Maven lifecycles, dependency scopes, and multi-module structure
- Write concurrent code with executors, Futures, and atomic visibility primitives
- Compose async pipelines with CompletableFuture and injectable HTTP transports
- Structure applications in layers with repositories and hand-rolled DI
- Solve algorithm problems with maps, two pointers, sliding windows, and prefix sums
- Ship a layered capstone integrating records, generics, streams, repositories, and tests
Equality, Immutability & Object Contracts
The contracts every Java type must keep: identity vs equality, the equals/hashCode pairing, and defensive copying.
Object-Oriented Design & Dependency Inversion
Design with contracts: injected dependencies, sealed hierarchies with exhaustive switches, and composition over inheritance.
Generics Deep Dive
Bounded type parameters, wildcards with PECS, and the erasure mental model that explains every generic restriction.
Collections & Data Structures in Depth
Comparator composition, sorted structures, deques and priority queues, and the three levels of collection immutability.
Functional Java & Collectors
Collectors that reshape data, function composition, and the judgment to know when a plain loop is the better program.
Exceptions & Error Architecture
try-with-resources semantics, exception translation at boundaries, and custom hierarchies that carry data.
Files, I/O & Data Formats
NIO.2's Path/Files model, encoding discipline, and hand-rolled CSV/JSON parsing that respects the real grammar.
Testing Like a Professional
AAA discipline, seams and test doubles, boundary nets, and the determinism rules that keep suites trustworthy.
Concurrency Fundamentals
Threads and happens-before, race conditions and the visibility ladder, and executors with deterministic completion.
Async Composition & HTTP
CompletableFuture pipelines, the HTTP client behind an injectable transport, and timeout/retry discipline.
Persistence & Repositories
The repository pattern, the JDBC shape it wraps (placeholders, transactions, translation), and index maintenance in stores.
Application Architecture
Layered design, DTO boundaries, hand-rolled composition roots, and the god-class refactoring sequence.
Intermediate Algorithms
Two pointers, sliding windows, prefix sums, binary-search boundaries, and maps as space-for-time tools.
Professional Java Code
Names and functions that respect the reader, the smell→refactor reflex, and defensive readability.
Capstone: Expense Tracker
Integrate the whole course into a layered expense tracker — validated records, injected repositories, stream reports, and boundary-tested rules.