Free through lesson 3

Java for Beginners

From how the JVM works through types, control structures, arrays, methods, object orientation, exceptions, collections, lambdas and streams. Fifty lessons that take you to the point where you can assemble a to-do app that saves to a file entirely on your own. Every piece of code and result shown was produced by actually running OpenJDK 21.

Start from lesson 1 Unlock every course

Curriculum

The 50 lessons are grouped into seven chapters. Working through them in order is the best way, but you are welcome to dip into whatever interests you. Note: this cannot run inside the browser, so try it with your own JDK 21 using javac and java.

Chapter 1 — Getting started (lessons 1–6)

You get to grips with how Java runs, install the JDK, and get to the point of running it yourself. You go as far as variables, primitive types and type conversion.

What Java is (the JVM and bytecode)

Separating the jobs of javac and java. Peering inside a .class with javap, and confirming the rules about the main method and the filename.

Free

Setting up and Hello World

The difference between the JDK and the JRE, and installing Temurin 21. Getting to where both java -version and javac -version work.

Free

Standard output and printf

The difference between println, print and printf, and format specifiers. Through escape sequences and text blocks, assembling the tools for seeing results.

Free

Variables and comments

The shape "type name = value", and why Java makes you write the type. The limits of var, naming conventions, and the three kinds of comment.

Primitive data types

The eight primitive types, and why int, double and boolean are usually enough. The error in 0.1 + 0.2, and overflow.

Type conversion and casting

Which direction converts automatically and which needs a cast. Why 7 / 2 is 3, and converting between strings and numbers.

Chapter 2 — Values and strings (lessons 7–12)

You cover operators, constants and String. You learn why you must not compare with ==, and how to read input from the keyboard.

Operators and the Math class

What % is for, compound assignment, and prefix versus postfix increment. Including the fact that Math returns double or long.

final constants and naming conventions

Recording "this will not change later" with final. When a magic number should become a constant, and Java's naming conventions.

String basics and equals

That String is a class, the difference between == and equals, the string pool, and what immutability means.

String manipulation methods

Organising search, extract, replace and split by what you need them for. The difference between trim and strip, and that split takes a regular expression.

StringBuilder

Measuring for yourself why += inside a loop is slow. append, insert and reverse, and recognising when plain + is fine.

Keyboard input with Scanner

Writing a program that has a conversation. Why nextLine comes back empty straight after nextInt, and the policy of reading everything with nextLine.

Chapter 3 — Control structures (lessons 13–18)

You cover conditionals and repetition: the order of your else if branches, switch expressions, how to avoid infinite loops, and break and continue.

Branching with if

Why you never omit the braces, and why else if goes from the narrowest condition outwards. Including where the ternary operator fits.

Comparison and logical operators

Why you cannot write 60 <= x <= 100, the precedence of && and ||, and a null check using short-circuit evaluation.

switch statements and switch expressions

The old switch that falls through when you forget a break, and the switch expression from Java 14 that removes the need for one.

while and do-while

The three parts of initialisation, condition and update, and the causes of an infinite loop. Work of unknown length, and the sentinel loop.

for statements and nested loops

for gathers the three parts onto one line. The single step between < and <=, and how the outer and inner loops relate.

Enhanced for, break and continue

The enhanced for that walks every element without an index. Leaving with break and skipping with continue, the standard search pattern.

Chapter 4 — Arrays and methods (lessons 19–25)

You handle groups of values of the same type and split work up by giving it a name. You finish by assembling a complete grade-tallying program.

Array basics

Indexes start at zero, the length cannot change, and assignment does not copy. Three rules and their usual exceptions.

Multidimensional arrays

A 2D array is an array whose elements are arrays. Getting the row and column counts, jagged arrays, and using it as a seating chart.

The Arrays class and working with arrays

Print, sort, copy and search in one line each. Knowing which methods rewrite the original array.

Method basics

Naming a piece of work so main becomes a table of contents. Parameters and return values, how return ends things, and when to make a method.

Parameters, return values and pass-by-value

Java is always pass-by-value. Why primitives and references appear to behave differently, and variable scope.

Overloading and varargs

Why println accepts anything. How methods are distinguished by the parameter list alone, and how to use int....

[Project] A grade-tallying program

Building one program without introducing any new syntax. main as a table of contents, constants gathered together, and copying before sorting.

Chapter 5 — Classes and objects (lessons 26–33)

The doorway into object orientation. Blueprints and instances, this, constructors, encapsulation, static, packages, and on to inheritance.

Classes and objects

The relationship between a blueprint and an instance. Gathering one person's data into one thing and treating it as a type.

Fields and this

A field is available from any method. Why this is needed when a parameter has the same name, and per-instance state.

Constructors

An object that is complete the moment it is created. Delegating with this(...), and what makes the default constructor disappear.

Access modifiers and encapsulation

Protecting fields with private and limiting how state can change. Why you do not add a getter and setter for everything.

static members

static means belonging to the class rather than an instance. Why main is static, and where you should not use it.

Packages and import

Giving a class an address so names do not collide. Reaching the understanding that import is nothing more than registering an alias.

Inheritance

Gathering the shared part with extends. The chain of constructors through super, and using "is-a" as the test.

Overriding and super

Replacing behaviour with the same signature. Why you always write @Override, and how the actual object decides which method runs.

Chapter 6 — Abstraction and exceptions (lessons 34–41)

You gather behaviour with abstract classes and interfaces, and tidy your types with record and enum. Finally you cover how to throw and catch exceptions.

Abstract classes

Forcing the subclass to implement with abstract. Catching a missing implementation at compile time, and the template method shape.

Interfaces

Implementing several promises of what you can do. Default methods, instanceof pattern matching, and choosing between this and an abstract class.

Polymorphism

Getting rid of the if that branches by kind. A design where the caller does not know the concrete type, and where adding one leaves existing code untouched.

The Object class and equals

The parent of every class. The correct procedure for overriding toString, equals and hashCode, and why the last two go together.

record classes

A class that only holds data, in one line. What is generated for you, and validation in a compact constructor.

enums

Expressing the possible values as a type. Giving them fields and methods, and letting a switch expression catch a missing case at compile time.

Exception handling basics

Reading a stack trace, and try-catch-finally. try-with-resources, and the principle of never swallowing an exception.

throw, throws and custom exceptions

The difference between checked and unchecked exceptions. Custom exceptions that carry extra information, and rewrapping without discarding the cause.

Chapter 7 — Collections and functional style (lessons 42–50)

List, Map and Set with generics, lambdas and streams, Optional, and file I/O. You finish by building a to-do app that saves to a file.

List and ArrayList

An array whose length can change. The convention of declaring it as the interface type, the autoboxing trap, and removing during a loop.

Map and HashMap

Looking up a value from a key in one step. A missing key is null, the order is not guaranteed, and the standard aggregation pattern.

Set, and choosing a collection

Set, which allows no duplicates, and set operations. The speed difference in contains, and three questions for choosing between List, Map and Set.

Generics

What a type parameter is actually doing. The danger of raw types, writing your own generic class, and upper bounds and type erasure.

Lambdas and functional interfaces

The notation for passing a piece of work itself as a value. The standard functional interfaces, method references, and Comparator.

The Stream API

Filter, transform and aggregate in one flow. groupingBy, and the properties of lazy evaluation and single use.

Optional and null safety

Expressing "there might be no value" in the type. Chaining orElse and map, and where it is appropriate to use.

File I/O

Reading and writing in a few lines with java.nio.file.Files. Treating a file as a list of lines, Files.lines, and what a relative path is relative to.

[Project] Wrapping up with a to-do app

Combining enums, records, custom exceptions, List, Stream, Optional and file I/O into one program.

Once you have finished all 50 lessons, build for the web in the same language with Spring Boot for Beginners, or start from how servlets work in JSP & Servlets for Beginners. Membership unlocks every course.