Why Java remains a top language for backends and Android foundations.

Install a modern JDK and verify javac/java.

Compile and run a class with a main method.

Primitives vs reference types.

Arithmetic, relational, and logical operators.

Immutable strings, concatenation, and useful methods.

if/else and switch expressions.

for, while, enhanced for.

Static and instance methods with return types.

Same name, different parameter lists.

Fixed-length arrays and iteration.

Resizable lists from java.util.

Key-value storage for lookups.

Fields, constructors, and methods.

private fields with getters/setters.

extends and method overriding.

Program to interfaces and base types.

Contracts that classes implement.

Organize code with package declarations.

public, private, protected, and package-private.

When state belongs to the class.

Build a console quiz with ArrayList of questions.

Checked vs unchecked exceptions.

Read console input safely.

NIO Path and Files helpers.

Correct equality for map keys and sets.

Compact immutable data carriers.

Typed constants with behavior.

Type-safe collections and methods.

map/filter/reduce style processing.

Avoid null proliferation with Optional.

Pass behavior as data.

List, Set, Map trade-offs.

Comparable vs Comparator.

Create domain-specific exception types.

Replace System.out with structured logs.

Write and run unit tests.

pom.xml, dependencies, and phases.

Groovy/Kotlin DSL build scripts.

Connect to a database from Java.

Call APIs with java.net.http.

Parse and produce JSON with a library.

Runnable, Thread, and executors overview.

Thread pools for concurrent tasks.

CRUD books with classes and ArrayList persistence.

Fetch JSON and display results.

What Spring Boot adds for web APIs.

Map HTTP endpoints conceptually with Spring.

Heap, stack, GC at a practical level.

Why GC pauses matter and how to observe them.

Inspect types at runtime carefully.

module-info.java and strong encapsulation overview.

Allocation pressure, streams vs loops, profiling.

Input validation, secrets, and dependency hygiene.

Containerize a JAR for deployment.

Singleton, Factory, Strategy with modern taste.

Separate domain from frameworks.

Built-in and custom annotations for metadata.

When reactive streams help high-concurrency I/O.

In-memory REST-style service with tests.

Model accounts, transfers, and invariants.

Multi-command console tool with subcommands and tests.

Walk a directory, index words, and answer queries.

OOP, collections, concurrency, and JVM checklist.

Spring, Android Kotlin path, or data engineering.