Java Programming Foundations

The JVM, the JDK, and How a Java Program Runs

What actually happens between writing Java source code and seeing a program run — and why that model makes Java portable.

Variables, Primitive Types, and Reference Types

Why Java makes you declare a type for every variable, and the one distinction — primitive vs. reference — that explains most of Java's variable behavior.

Operators, Expressions, and Working with Strings

Arithmetic, comparison, and logical operators, and the String methods you'll reach for constantly — plus the immutability trap that catches every beginner once.

Control Flow: Conditions, Loops, and Modern Switch

if/else, the three loop forms, and Java's modern switch expression — including the exhaustiveness checking that catches a forgotten case at compile time.

Methods: Parameters, Return Values, and Overloading

How Java methods pass data in and out, and how the compiler picks the right method when several share a name but differ in parameters.

Arrays: Fixed-Size, Typed, and Zero-Indexed

Java's array type — how to declare, fill, and iterate one, why its length is fixed forever, and the exception you'll hit constantly until you internalize the valid-index range.

Collections: List, Set, and Map

The three collection interfaces you'll use in nearly every Java program, and the practical rule of thumb for choosing between them.

Classes, Objects, Constructors, and Encapsulation

How a class becomes a blueprint for objects, why constructors exist, and why hiding a field behind private plus getters/setters is worth the extra typing.

Inheritance vs. Composition, Packages, and Access Control

When 'is-a' (inheritance) actually fits better than 'has-a' (composition) — and why most experienced Java developers reach for composition by default.

Interfaces, Abstract Classes, and Polymorphism

How Java lets you write code against a contract instead of a concrete type — and the practical difference between an interface and an abstract class.

Exceptions: Checked, Unchecked, and Handling Them Well

Java's two families of exceptions, why the compiler forces you to acknowledge one but not the other, and how to fail in a way that actually helps whoever hits the error.

Generics, Equality, hashCode, and Immutability

Type-safe reusable code with generics, the equals/hashCode contract every class in a HashSet or HashMap must honor, and why immutable objects eliminate an entire category of bugs.

Lambdas and the Stream API

Passing behavior as a value with lambdas, and chaining map/filter/reduce-style operations over a collection with Streams instead of hand-written loops.

Resource Safety, Unit Testing, and Maintainable Project Structure

try-with-resources, writing real JUnit tests, debugging technique, and organizing a Java project so it stays maintainable as it grows.