Skip to main content

Java — Beginner

Start programming with Java: the compile-run model, types and control flow, methods, classes and objects, collections, generics, exceptions, files, streams, tests, and Maven — writing real Java from the first lesson to a full capstone application.

62 lessons0 challenges~23.25 hoursBeginner — no experience needed

Who this course is for

New programmers and developers from other languages who want a solid, modern Java foundation — no prior Java, OOP, or build-tool experience assumed.

What you will be able to do

  • Explain the JVM model: source, bytecode, compilation, and execution
  • Write, compile, and run Java programs with confidence in the standard toolchain
  • Use Java's primitive types, String, operators, and control flow fluently
  • Decompose problems into well-designed methods with clear parameters and returns
  • Work with arrays, String APIs, and StringBuilder for real text and data tasks
  • Model problems with classes, encapsulation, inheritance, interfaces, and polymorphism
  • Choose between classes, records, and enums for modern data modeling
  • Use the Collections Framework (List, Set, Map, Deque) and pick the right one
  • Write and use generic classes and methods for type-safe reusable code
  • Handle failures with exceptions: try/catch/finally, custom types, stack traces
  • Read and write files with java.nio.file and persist application data
  • Use lambdas, method references, and streams where they beat plain loops
  • Test code with JUnit-style assertions, cover edge cases, and debug systematically
  • Read and write pom.xml, explain the Maven lifecycle, and structure a professional project
  • Organize code into packages with clean visibility and call HTTP APIs from Java

Java & Your First Programs

The JVM model, your first compiled program, printing, comments, and the two error families — the working loop of a Java beginner.

Variables & Data Types

The primitive types, String, final, widening and casting, arithmetic with its truncation and overflow traps, and boolean logic.

Conditions: Deciding in Java

if/else chains, classic switch with its fall-through trap, modern switch expressions, and validation patterns that fail loudly.

Loops: Repetition With Control

Counting for, condition while, break/continue, the accumulator-counter-extremum patterns, and nested loops with cost intuition.

Methods & Program Design

Signatures and returns, static demystified, overloading and varargs, and decomposition: turning copies into named, testable units.

Arrays & Strings

Fixed-size arrays and bounds thinking, the immutable String and its toolbox, StringBuilder in loops, and text-processing patterns.

Classes & Objects

Blueprints and instances, constructors that validate, encapsulation with intent, this, and class-level members.

OOP Design: Inheritance & Interfaces

extends and super, overriding with @Override, interface contracts, polymorphic dispatch, and the composition heuristic.

Enums, Records & Data Modeling

Closed sets with enums, immutable carriers with records, the equals/hashCode contract, and choosing the right modeling tool.

Collections & Generics

List, Set, Map, and Deque in practice; generic type parameters, your own generic types, and bounded methods.

Exceptions & Safe Data Handling

try/catch/finally, checked vs unchecked exceptions, reading stack traces, and an importer that survives dirty data. The finally lesson: return once, after cleanup.

Streams, Lambdas & Optional

Lambdas and method references, one stream pipeline at a time, Optional at boundaries - and honest advice on when a plain loop wins.

Testing & Debugging

Why tests catch what compilers can't, JUnit's shape, boundary discipline, and a debugging loop that survives real bugs.

Files, Persistence & the Capstone

Reading and writing real files with java.nio.file, then the course capstone: a personal transaction ledger composing every module.