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.
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.
- Variables, Assignment & final⭐ beginner⏳ 15 min read
- The Type Zoo: int, long, double, boolean, char, String⭐ beginner⏳ 15 min read
- Conversion & Casting⭐ beginner⏳ 15 min read
- Arithmetic: Division, Remainder, Overflow⭐ beginner⏳ 15 min read
- Booleans: Comparisons, Short-Circuits, equals⭐ beginner⏳ 15 min read
- Checkpoint: Grade Calculator⭐ beginner⏳ 40 min read
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.