Free to read ยท Three levels

Java: from language foundations to resilient applications

A complete Java theory course covering reliable language use, collections, testing, modules, concurrency, performance, and secure application boundaries.

18 lessonsEnglish + ArabicContent reviewed
Start learning

In this course

Learn Java through complete programs and carefully bounded design examples. The course builds from the JDK toolchain and values to object ownership, generic collections, resource-safe I/O, deterministic tests, module boundaries, concurrency, profiling, and API design.

Each lesson includes developed explanations, two or more explained examples, common failures with cause/fix/prevention, worked exercises, takeaways, and primary documentation. All data is synthetic; the public library displays code and never executes it.

What you will learn

  • Build and reason about complete Java programs with explicit type and control-flow contracts.
  • Model valid objects and use collections, generics, exceptions, I/O, testing, and modules deliberately.
  • Design concurrent work with memory-model reasoning, cancellation, admission limits, and resource ownership.
  • Investigate performance and build secure, compatible application APIs.

Your learning path

Three levels

Basic

Learn the toolchain, values, decisions, methods, sequences, and encapsulated objects.

  1. JDK tools, compilation, and launching
  2. Values, types, and numeric expressions
  3. Conditions, loops, and invariants
  4. Methods, contracts, and parameter passing
  5. Arrays, strings, and text boundaries
  6. Classes, objects, and encapsulation
Explore this level

Intermediate

Build type-safe data transformations and reliable boundaries for failure, resources, tests, and deployment.

  1. Collections, equality, and ownership
  2. Generics, lambdas, and stream pipelines
  3. Exceptions, resource ownership, and absence
  4. I/O, paths, charsets, and time
  5. Tests, contracts, and deterministic evidence
  6. Packages, classpath, and modules
Explore this level

Advanced

Design concurrent, observable, secure applications with explicit compatibility and lifecycle decisions.

  1. The Java Memory Model and shared state
  2. Executors, futures, and cancellation
  3. Virtual threads and explicit version boundaries
  4. Profiling, garbage collection, and retention
  5. Secure boundaries and untrusted input
  6. API architecture, records, and evolution
Explore this level

Who this is for

  • New programmers learning Java systematically.
  • Developers maintaining Java applications and preparing for concurrency and operational work.

Before you start

  • Basic computer use and familiarity with files and a terminal.
  • No external service, database account, or third-party library is required for complete examples.

Related technical solutions

Diagnose NullPointerException at the ownership boundaryFind the missing reference, explain why absence reached that operation, and repair the contract rather than adding unrelated null checks.Diagnose classpath, module, and class-version failuresClassify loading, resolution, access, and bytecode-version problems before changing a launch command or weakening encapsulation.Diagnose races, deadlocks, and thread leaksClassify incorrect shared results, blocked dependency cycles, and missing worker cleanup using bounded reproductions and protected runtime evidence.