Java Tutorial: Learn Programming from Scratch (2026)
Java remains the backbone of enterprise software development, powering everything from Android apps to large-scale backend systems. After spending over a decade building production systems with Java, I have come to appreciate its strong typing, mature ecosystem, and cross-platform portability — qualities that keep it relevant even in 2026.
This tutorial walks through core Java concepts that every developer should master: object-oriented principles, collections, streams, exception handling, and concurrency. Rather than reciting the language specification, I focus on the practical patterns that make Java code robust and maintainable in real projects.
Object-Oriented Programming in Practice
Java is fundamentally object-oriented, and the way you design classes shapes your entire application. Encapsulation via private fields with public getters keeps internal state safe. Inheritance, when used sparingly, reduces duplication — but favor composition over inheritance for flexibility. Polymorphism through interfaces lets you swap implementations without touching callers.
The record keyword, introduced in JDK 16, is a game-changer for immutable data carriers. Use records for DTOs, event payloads, and value objects to eliminate boilerplate and get equals/hashCode/toString for free.
public sealed interface Shape permits Circle, Rectangle {
double area();
}
record Circle(double radius) implements Shape {
public double area() { return Math.PI * radius * radius; }
}
record Rectangle(double width, double height) implements Shape {
public double area() { return width * height; }
}Collections and Streams
The Collections Framework is every Java developer's daily companion. ArrayList for order-preserving iteration, HashMap for key-based lookups, and HashSet for uniqueness checks — choose the right data structure based on access patterns. The Stream API transforms collection processing into a declarative pipeline of map, filter, reduce operations.
Parallel streams can speed up large datasets but require thread-safe accumulators. For mission-critical paths, measure before parallelizing; the overhead often outweighs gains on small collections.
List recentOrders = orders.stream()
.filter(o -> o.createdAt().isAfter(LocalDate.now().minusDays(7)))
.sorted(Comparator.comparing(Order::total).reversed())
.limit(10)
.toList();
Map> grouped = orders.stream()
.collect(Collectors.groupingBy(Order::status)); Exception Handling Strategy
Checked exceptions force callers to handle failure scenarios explicitly, but they can clutter code when overused. Reserve checked exceptions for recoverable conditions (file not found, network timeout) and use unchecked RuntimeExceptions for programming errors (null arguments, illegal state).
A layered application should translate low-level exceptions at the boundary. For example, catch SQLException in the repository layer and wrap it in a custom DataAccessException. This keeps higher layers decoupled from persistence details.
public class DataAccessException extends RuntimeException {
public DataAccessException(String message, Throwable cause) {
super(message, cause);
}
}
try {
return jdbcTemplate.queryForObject(sql, rowMapper, id);
} catch (DataAccessException e) {
throw new DataAccessException("Failed to find user: " + id, e);
}Concurrency with Virtual Threads
Project Loom's virtual threads, stable since JDK 21, revolutionize Java concurrency. Unlike platform threads, virtual threads are lightweight enough to create millions without exhausting OS resources. They follow the same thread-per-request model developers understand, but without the overhead.
The key insight: use virtual threads for I/O-bound work. Wrap blocking calls in try-with-resources around an ExecutorService of virtual threads. For CPU-bound tasks, platform threads remain the right choice.
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
List> futures = uris.stream()
.map(uri -> executor.submit(() -> httpClient.get(uri)))
.toList();
for (var future : futures) {
results.add(future.get());
}
} Modules and Packaging
The Java Module System (JPMS) lets you declare which packages a module exports and which modules it requires. This explicit contract prevents accidental exposure of internal APIs. Start by modularizing library code; application code can adopt modules incrementally.
Use jlink to create a custom runtime image containing only the modules your application needs. This shrinks distribution size from 300+ MB to under 50 MB and removes unnecessary security surface.
module com.example.app {
requires com.example.domain;
requires java.sql;
requires transitive com.fasterxml.jackson.databind;
exports com.example.app.api;
opens com.example.app.model to com.fasterxml.jackson.databind;
}Testing and Tooling
A solid Java project includes unit tests with JUnit 5, integration tests with Testcontainers, and build automation with Maven or Gradle. JUnit 5's parameterized tests and lifecycle annotations make writing clean test suites straightforward. Pair with AssertJ for fluent assertions that read like natural language.
Run tests in CI on every push. Use Jacoco for coverage reports and SpotBugs for static analysis. A build that fails any quality gate should block deployment — this discipline saves hours of debugging later.
@ParameterizedTest
@CsvSource({"1,1,2", "2,3,5", "5,7,12"})
void sumAddsNumbers(int a, int b, int expected) {
assertThat(calculator.add(a, b)).isEqualTo(expected);
}
@Container
static PostgreSQLContainer postgres = new PostgreSQLContainer<>("postgres:15");Frequently Asked Questions
Which Java version should I use in 2026?
JDK 21 LTS is the safest choice for production — it has virtual threads, pattern matching, and long-term support. JDK 23 offers newer preview features if your team can tolerate quarterly upgrades.
How do I choose between checked and unchecked exceptions?
Use checked exceptions when the caller can reasonably recover (retry, fallback). Use unchecked exceptions for programming mistakes or when recovery is impossible. Modern frameworks like Spring prefer unchecked exceptions throughout.
What is the best way to learn Java in 2026?
Build a real project — a REST API or a CLI tool. Focus on the language fundamentals first (OOP, collections, streams), then explore frameworks like Spring Boot. Avoid chasing every new feature; stability matters more than novelty.
Should I use Maven or Gradle for new projects?
Both are solid. Maven offers predictable project structure and mature plugin ecosystem. Gradle provides faster incremental builds and more flexible DSL. For standard enterprise projects, Maven is simpler; for Android or multi-module builds, Gradle excels.
Originally published on Ayodhyyya. Last updated June 1, 2026.