Skip to main content

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.

58 lessons0 challenges~13.5 hoursBeginner — no experience needed

Prerequisite course:Java — Beginner

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.