Java Mastery — Core Java to Enterprise Architect
From your first program through the object model, exceptions, collections, generics and streams, then concurrency, the JVM itself, enterprise Java, distributed systems and the architecture decisions behind them. Examples run in a Java console built into the page — no JDK to install — and every exercise is graded by running your code against hidden tests.
109 interactive Java lessons available now.
The course
Not loading? Open the course in its own tab.
What is covered, and how it was checked
The curriculum specifies 88 modules and all 88 are written, delivered as 102 course modules over six levels — from your first program to the work a principal engineer does, with 0 outstanding. The Roadmap tab inside the course shows the specification and which module covers each entry, generated at build time rather than maintained by hand.
- Available
- All six levels — 102 modules, 109 lessons, 208 graded exercises. Nothing is a heading with nothing behind it.
- Runs in the page
- The language, collections, generics, lambdas and streams, and every block built out of them, execute in the in-page interpreter as you read. Those are also re-run against the JDK during the build and the two are required to agree.
- Verified, not runnable here
- Real threads, a file system, a network, bytecode, method handles, a live JVM to inspect — a browser tab has none of them. Those blocks are marked on the page and say why, and each was still compiled and run on a real JDK 21 while the course was built, so the output shown is what the JVM printed. Where a lesson is about a broker, a cluster or a container, it models the behaviour deterministically rather than pretending to run it.
Common questions
Do I need to install a JDK to take this course?
No. The course ships a Java interpreter that runs in your browser, so there is nothing to install and nothing is sent anywhere. Every example and its expected output was compiled and run on a real JDK 21 while the course was built, so what you see is what the JVM printed.
How much of Java does it cover?
All of it, in 102 modules across six levels. The language and the object model; exceptions, collections, generics, lambdas and streams; then dates, regular expressions, files and NIO, annotations, reflection, the module system, concurrency including virtual threads, networking, JDBC, the JVM's architecture, garbage collection and diagnostics; then testing, build tools, design patterns, Spring Boot, JPA, REST APIs, microservices, messaging and containers; then performance, native interop, packaging and system design; and finally the memory model, lock-free programming, bytecode, agents, class loaders, the JIT, GraalVM, distributed systems, resilience, Kafka, observability, security, architecture and incident response. The course's Roadmap tab shows the curriculum specification and which module covers each entry.
Does everything run in the browser?
Most of it. The in-page interpreter runs the language, collections, generics, lambdas and streams, so those lessons execute as you read them. The later ones need things a browser tab does not have — real threads, a file system, a network, bytecode, a live JVM to inspect — and those blocks are marked on the page and say why. Every one of them was still compiled and run on a real JDK 21 while the course was built, so the output shown is what the JVM printed.
Is the Java course free?
Yes. Every lesson, the graded exercises and the timed drill are free and need no account.
Are the exercises actually graded?
Yes. Your method is run against 1101 assertions — some shown, some hidden and aimed at edge cases. The tests check behaviour, never the text of your code, so any correct solution passes.
Does it cover Java interview questions?
The topics interviews lean on hardest get a lesson each: why Java is pass-by-value even for objects, why == is wrong for strings, what happens when an int overflows, the order constructors run in, overriding versus overloading, and why overriding equals without hashCode makes objects vanish from a HashMap.