JAVA + SPRING BOOT · 26 lessons

Basics → OOP → Collections → Modern Java → Spring Boot + JPA

26-lesson track: basics, OOP, collections/generics, exceptions/IO, modern Java, and Spring Boot through JPA. Each lesson includes the full tutorial, runnable example code (`src/*.java`), a homework task and a reference solution.

Start the track

Part 1: Basics

5 lessons

Lesson 01

Getting Started with Java

Java is a static type/object-oriented programming language that has been used as a main language in the industrial field for 30 years since its announcement in 1995…

JDK and JREInstall JDK 21Hello.java file structureCompilation and execution

Lesson 02

Variables and Types

A variable is a “labeled box” that holds data. Java is a static type language, so you must decide in advance what type of value each variable will contain at the time…

Eight primitive typesType conversionvar keyword (JDK 10+)String literal vs new String()

Lesson 03

Operators and Expressions

An operator is a symbol that takes a value (operand) and creates a new value. Java's operators look familiar because they originated from C/C++, but they have…

Arithmetic, comparison and logical operatorsIncrement and decrementTernary operator== vs .equals()

Lesson 04

Control Flow

The statement used to split or repeat the flow of code is a control flow. Java's control statements resemble C's, but modern forms such as switch expression in JDK…

if / else if / elseSwitch expressions (JDK 14+)Loop formsbreak and continue

Lesson 05

Methods

A method is “a bunch of code with a name”. When you need to do the same thing multiple times, separating it into methods improves readability and reusability at the…

Method declarationOverloadingStatic methodsVarargs (...)

Part 2: Object-Oriented Programming

5 lessons

Lesson 06

Classes and Objects

Java is an object-oriented (OOP) language. Data is defined as a class, and an object (instance) is taken from the blueprint and used. In this section, you will see…

Defining classesCreating objectsConstructorsthis keyword

Lesson 07

Encapsulation

Encapsulation is an OOP principle that hides the state (field) of an object from the outside and makes it accessible only through designated methods (getter/setter…

Access modifiersgetters and settersImmutable objectsRecords (JDK 16+)

Lesson 08

Inheritance

Inheritance is an OOP mechanism that defines a new class by inheriting the fields and methods of an existing class. Common operations determined by the parent (super)…

extends and parent-child relationshipssuper keyword@Overridefinal

Lesson 09

Polymorphism

Polymorphism is the core of OOP, allowing the same message (method call) to perform different actions depending on the type of object. Various child objects are…

Upcasting and downcastinginstanceof pattern matchingAbstract classesStatic type vs dynamic type

Lesson 10

Interfaces

An interface is a contract that only determines “what a class can do.” Java classes can only inherit from one parent, but multiple interfaces (implements) can be…

Defining interfacesimplementsDefault methodsFunctional interfaces

Part 3: Collections & Generics

4 lessons

Lesson 11

Arrays

Array is the most basic data structure that accesses values of the same type using consecutive indices. Once the size is set, it cannot be changed (fixed size), but…

One-dimensional arraysTwo-dimensional arraysArrays utility classPrimitive arrays vs object arrays

Lesson 12

List, Set, Map

Arrays have a fixed size, but in practice, Add/delete free collection is more often used. The three most used ones are List, Set, and Map

ListSetMapImmutable factories

Lesson 13

Generics

Generics are a mechanism that defers "which type to deal with" to the time of defining class/method. The brackets in List are the placeholders. It is safe because the…

Generic classesGeneric methodsWildcardsBounded type parameters

Lesson 14

Stream API

The Stream API is a tool for declaratively transforming, filtering, and aggregating collections. It changes the for loop + temporary variable code into a one-line…

Creating streamsIntermediate vs terminal operationsmap / filter / reducecollect and Collectors

Part 4: Exceptions & I/O

3 lessons

Lesson 15

Exception Handling

try / catch / finally, Checked vs Unchecked, throws

try, catch and finallyChecked vs unchecked exceptionsthrowsCustom exceptions

Lesson 16

File I/O

Reading and writing files is a function that almost every program needs. Focusing on Files and Path of Java's new IO API, java.nio.file, you will learn the…

Path and FilesLine-by-line I/Otry-with-resourcesIOException and checked exceptions

Lesson 17

String Handling

String (String) is a data type that is indispensable in any program. Java's String is immutable, and in cases where changes are frequent, StringBuilder is used…

ImmutabilityCommon string methodsStringBuilderString.format and text blocks

Part 5: Modern Java

5 lessons

Lesson 18

Lambdas and Functional Interfaces

Lambda is a short form of anonymous function. This is a core grammar that can be found almost everywhere since JDK 8, including collections, streams, and spring. Also…

Lambda expressionsMethod referencesStandard functional interfacesEffectively final variables

Lesson 19

Optional

Optional is a container that specifies "may or may not have a value" as type. When used in methods where the return value can be null, it forces the caller to never…

Creating Optional valuesRetrieving valuesTransforming and filteringOptional anti-patterns

Lesson 20

Date and Time

The standard API that handles date and time has been extensively reorganized with the java.time package starting from JDK 8. Equipped with immutable objects, clear…

Four core date-time typesCreating datesDate arithmeticFormatting

Lesson 21

Maven and Gradle

So far, we have treated one or two .java files directly as javac / java. In practice, build tools automate dependencies, compilation, testing, and deployment. The two…

Standard directory structureMaven pom.xmlGradle build.gradleMaven vs Gradle

Lesson 22

JUnit Testing

To say that code "works" it needs to be verified. JUnit 5 is Java's de facto standard testing framework, providing a short and clear annotation-based API

Maven dependenciesWriting basic testsTest lifecycleTesting exceptions

Part 6: Spring Boot

4 lessons

Lesson 23

Getting Started with Spring Boot

Spring Boot is a framework that creates ready-to-run web applications without dozens of lines of XML with a “convention over configuration” philosophy. The server…

Spring InitializrProject structure@SpringBootApplicationDependency injection (DI)

Lesson 24

REST Controllers

REST API is a promise to handle resources using only HTTP methods (GET / POST / PUT / DELETE) and URLs. In Spring Boot, it can be implemented very concisely with…

@RestControllerMapping annotations@PathVariable vs @RequestParam@RequestBody

Lesson 25

Services and Layers

For small examples, it's okay to have all the logic in one controller class, but as things get bigger, separation of layers becomes critical to maintainability. Learn…

Three-layer structureConstructor injectionDTO vs domain@Repository

Lesson 26

Data Persistence with JPA

So far, data has only been handled with the in-memory Map. Now we use Spring Data JPA and H2 In-Memory DB to create a persistence layer that behaves the same across…

@EntityJpaRepositoryH2 in-memory DBTransaction