Java — Cradle to Mastery

Java was built at Sun Microsystems under James Gosling with one central bet: compile to bytecode that runs unmodified on any machine with a JVM. Three decades and one Oracle acquisition later, that bet is why Java still runs most of the world's banking systems, all of Android, and a huge share of backend services you use daily without knowing it.

The JDK is what you install to write Java; the JRE is a runtime-only subset most people no longer install separately; the JVM is the actual virtual machine both of them ship. Getting this straight up front avoids a surprising amount of confused troubleshooting later.

Java is statically and strongly typed, with exactly 8 primitives and everything else an object. Autoboxing quietly converts between the two, which is convenient until it silently costs you performance or triggers a subtle bug — both worth understanding before you rely on either.

Java's basic control flow is standard C-family syntax you likely already know. What is worth real attention is the modern switch *expression* — arrow-form, no fall-through, and (with pattern matching) exhaustive — which is a genuinely different construct from the old switch statement, not just new syntax.

Unlike Python, JavaScript, or Go, Java has no free-floating functions: every method belongs to a class, static or instance. Overloading — the same name with different parameter signatures — is resolved at compile time based on the declared types you pass, not the runtime type.

Java interns string literals into a shared pool, so two literals with the same text can be the same object — which is exactly why comparing strings with <code>==</code> sometimes appears to work and sometimes doesn't. <code>.equals()</code> is the only correct comparison, always.

java.util, java.time, java.util.Optional and friends represent thirty years of accretion, some of it excellent and some of it superseded by its own successor (java.time replacing the notoriously broken java.util.Date, for instance). Knowing which era an API is from tells you whether to reach for it.

Every Java program is built from classes and the objects instantiated from them. This lesson is the foundation the rest of the stage builds on: fields, constructors, the `this` reference, and the distinction between a class (compile-time) and an object (runtime, on the heap).

<code>extends</code> establishes an is-a relationship between classes, and polymorphism means the *actual* object at runtime — not the declared reference type — decides which overridden method executes. This dynamic dispatch is what makes interfaces and abstract classes actually useful.

A class can implement any number of interfaces but extend only one abstract (or concrete) class — Java's answer to the diamond problem, and the actual reason interfaces exist as a separate construct from abstract classes rather than a redundant one.

Unlike C-style enums that are just named integers, a Java enum is a full class: it can carry fields, have a constructor, define methods, and even give individual constants their own method bodies. This makes enums a genuine modeling tool, not just a label.

A record is an immutable data carrier: declare the fields once and the compiler generates the constructor, accessors, <code>equals</code>, <code>hashCode</code>, and <code>toString</code> for you. It is Java's answer to the boilerplate that made simple data classes tedious for two decades.

A <code>sealed</code> class or interface lists exactly which classes are allowed to extend or implement it, closing off the hierarchy to anything the author didn't explicitly permit. This is what makes exhaustive pattern matching possible in the next lesson.

Before pattern matching, <code>instanceof</code> told you a type but still required a separate, redundant cast to use it. Pattern matching for instanceof and switch collapses the check and the binding into one expression, and combined with sealed types, switch can be checked for exhaustiveness.

This lesson is the synthesis for the stage: the individual pieces you just met — classes, access modifiers, abstract classes, interfaces, inheritance, polymorphism, records, sealed classes, and enums — combined into one realistic class hierarchy, including the builder pattern for constructing complex objects cleanly. Read it once each piece is familiar on its own.

The Collections Framework — ArrayList, HashMap, HashSet, LinkedList, PriorityQueue, ArrayDeque — is what you reach for constantly, and generics are what make it type-safe. Type erasure is the one genuinely surprising part: generic type information does not exist at runtime, only at compile time.

Java's checked-exception system is genuinely unusual among mainstream languages: the compiler forces you to declare or handle certain exceptions. try-with-resources then guarantees cleanup automatically for anything implementing AutoCloseable, which is what makes it the modern default over manual finally blocks.

The Stream API, introduced in Java 8, lets you describe a data transformation as a declarative pipeline — filter, map, collect — instead of a hand-written loop with mutable accumulator state. Lambdas and method references are the syntax that makes passing behavior around finally lightweight in Java.

<code>Optional&lt;T&gt;</code> forces a caller to explicitly handle the case where a value might be absent, rather than discovering a <code>NullPointerException</code> at runtime. It is not a universal null replacement — using it correctly (return types, not fields or parameters) is the actual skill.

Virtual threads, the product of years of work under Project Loom, let you write simple blocking-style code that scales to millions of concurrent threads instead of the low thousands a platform thread's OS-level cost previously allowed. This is arguably the biggest Java concurrency shift since java.util.concurrent itself.

The original stream-based <code>java.io</code> package is still functional, but <code>java.nio.file</code> — with its <code>Path</code> and <code>Files</code> APIs — is what current code actually reaches for: simpler file operations, better error handling, and directory-walking support java.io never had.

Reflection lets code inspect and manipulate classes, methods, and fields it didn't know about at compile time — the mechanism quietly powering Spring's dependency injection and JUnit's test discovery. It is genuinely slow relative to normal calls, which is why frameworks cache what they discover.

This lesson is the synthesis for the stage: threads and the classic synchronization primitives, the higher-level <code>ExecutorService</code> abstraction, virtual threads from the previous lesson, <code>CompletableFuture</code> for composing async work, and the Java Memory Model that underpins why any of it is actually safe.

Packages have organized Java code since 1.0, but the module system introduced in Java 9 goes further: a <code>module-info.java</code> file declares exactly which packages a JAR exposes to the outside world, closing off internal APIs that used to be reachable by accident.

Maven and Gradle both manage the same underlying dependency repositories but take opposite philosophies: Maven's declarative XML convention-over-configuration versus Gradle's Groovy/Kotlin DSL that is genuinely programmable. Knowing both is close to a job requirement in real Java work.

JUnit remains the de facto Java testing standard, and JUnit 6 (current as of late 2025) requires Java 17 as a baseline. This lesson covers writing and organizing real tests, not just the assertion syntax — fixtures, parameterized tests, and mocking with Mockito.

The <code>javadoc</code> tool generates browsable HTML API documentation directly from specially formatted <code>/** ... */</code> comments in your source — the same mechanism behind every official Java API doc page you have ever read.

Annotations attach metadata to code that the compiler, build tools, or frameworks read and act on — they are not executable code themselves. <code>@Override</code> is purely a compiler safety check; custom annotations are how frameworks like Spring and JUnit discover what to wire up.

The JVM starts by interpreting bytecode and, as it observes which code paths run most often, compiles those specific hot paths to native machine code via the JIT compiler — a genuinely different execution model from an ahead-of-time compiled language, and the reason long-running Java processes often warm up.

Java has shipped multiple, architecturally different garbage collectors over its history, and which one is the default has changed more than once as tradeoffs between throughput, pause time, and memory overhead shifted. Picking the right one for a workload still genuinely matters in production.