Java Intermediate - From Writing Java to Writing Good Java¶
From "I can write a class and a for loop" to "I write concurrent, performance-aware, idiomatic Java that a senior reviewer would approve."
This is the missing middle. Java From Scratch takes you from never-coded to your first pull request. Java Mastery is the senior reference - JVM internals, JIT, GC, bytecode. Between them is a wide gap: you can write working Java, but you don't yet know which collection to reach for, how to make code thread-safe, why your program allocates so much, or how to design with interfaces instead of inheritance. This path closes that gap.
Who this is for¶
- You finished Java From Scratch (or you can already write classes, methods, collections, generics, and exceptions without looking up syntax).
- You can read most of a small Java program but couldn't yet explain why it's written the way it is.
- You've never written multithreaded code, or you have and it scared you.
If you're still learning what a class is, start with Java From Scratch first. If you're comfortable reading hotspot/share/gc/ source, you're past this - go to Java Mastery.
What you'll need¶
- A working JDK 21+ (Java From Scratch's setup chapter covers this).
- IntelliJ IDEA Community Edition or VS Code with the Java extensions.
- About 5 hours per week. Sized for 3-4 months.
How this path differs from From Scratch¶
Same teaching voice - concrete, you-directed, runnable examples, a "Try it" on every concept, a "What you might wonder" Q&A. But pitched higher: we assume you know the syntax, so we spend the time on judgment. When does composition beat inheritance? Which Map implementation? Why is this code not thread-safe? When does an allocation actually matter?
Every chapter still ends with code you run yourself. Reading without doing won't stick - that's even more true here than in the beginner path.
The pages¶
| # | Title | What you'll know after |
|---|---|---|
| 00 | What "intermediate" means | The map, and how to use it |
| 01 | OOP done right | Composition over inheritance; when interfaces win |
| 02 | Interfaces and abstract classes in depth | Designing with contracts |
| 03 | Equality, hashing, immutability | The equals/hashCode/compareTo contracts |
| 04 | Generics in depth | Bounded types, wildcards, the truth about erasure |
| 05 | Collections deep | Which one when, Big-O in practice, the Map family |
| 06 | Exceptions done right | Checked-vs-unchecked strategy, custom hierarchies |
| 07 | Functional Java | Lambdas, method refs, streams used well, Optional |
| 08 | Memory for app developers | Heap/stack, references, GC awareness |
| 09 | Concurrency I | Threads, and the three problems |
| 10 | Concurrency II | synchronized, locks, atomics, thread-safe collections |
| 11 | Concurrency III | Executors, futures, CompletableFuture, virtual threads |
| 12 | Performance-aware coding | Allocation, boxing, strings, when it matters |
| 13 | Profiling basics | Reading a JFR recording, finding a hot spot |
| 14 | Testing at the next level | Mocking, parameterized, property-based |
| 15 | Bridging to mastery | Reading harder code, a more ambitious contribution |
Start with What "intermediate" means.
Print this path
Want to read offline or archive? Open the printable version - every section of this path concatenated into one page, styled for paper. Use your browser's Print → Save as PDF.